Autonomous Driving AI para Donkey Car Garbage Collector

Use um TensorFlow SSD MobileNetV2 DNN na câmera Raspberry Pi plus Pi para construir um carro autônomo capaz de detectar objetos.

História

Este projeto mostrará como transformar um carro RC equipado com (Câmera Raspberry Pi + Pi) em um capaz de detecção de objetos e direção autônoma. Para fazer isso, implantaremos duas redes neurais profundas. Um para detecção de objetos e outro para direção autônoma usando inferência para direção e acelerador. Um RPi 3 funciona como o computador do veículo. Devido a recursos limitados no RPi, apenas uma das redes pode ser executada por vez.

A ideia é treinar a rede neural para identificar latas de lixo para que o carro possa recolhê-las de forma autônoma.

identificando carro e laptop

O projeto consiste em duas partes. Na primeira parte, o plano é usar uma rede convolucional de tamanho moderado para reconhecer objetos no feed de vídeo de entrada da câmera Pi. O TensorFlow será usado para implantar o modelo CNN e o OpenCV será usado para gerenciar o feed de vídeo da câmera Pi.

Na segunda parte, usaremos a clonagem comportamental para fazer o carro navegar autonomamente. O carro modificado também será ampliado com sensores adicionais, como sensor de distância ultrassônico, GPS e 6-DOF IMU, além de implementar recursos de telemetria adicionais.

Introdução

Em 2017 (um ano atrás), o Google lançou o MobileNet e, no início deste ano, o MobileNetV2. Essas redes são otimizadas de forma personalizada para funcionar em dispositivos incorporados, como smartphones. Coincidentemente, o MPU usado no RPi 3 se enquadra nesta categoria, pois pode rodar Linux ou Android.

O primeiro problema que se encontra é a RAM limitada e a capacidade computacional do Raspberry Pi 3. Mesmo que este seja um MPU quad core, ainda não é suficiente ao lidar com arquivos de peso massivo necessários para YOLO (apenas você Olhe uma vez) digite redes.

A primeira solução que vem à mente é enviar a imagem adquirida através da câmera Pi via WIFI para um PC externo e aí fazer o estágio de inferência de objetos e então enviar comandos para o Donkey Car. Em essência, temos que entrar em contato com a nave-mãe a cada passo. Isso é ineficiente, para não dizer impraticável em cenários em que a comunicação com um laptop externo não é possível.

Inicialmente testei uma rede VGG16 que era relativamente precisa ao detectar latas de lixo. No entanto, ele não poderia ser executado no RPi, pois os pesos sozinhos eram em torno de 350 MB! Para testar a rede VGG, consulte o código anexado no final com imagens semelhantes como entrada.

Problema:

python KerasVGG_test.py

Então, para resolver o problema de tamanhos de pesos enormes, vamos executar todos os modelos no RPi usando redes mais finas. Especificamente, vamos usar o CNN baseado em um detector de disparo único MobileNetV2. Este é um DNN que foi otimizado para ter pesos muito pequenos (relativamente).

A técnica é chamada de aprendizagem por transferência, pois estamos usando pesos de rede pré-treinados.

Antes de nos aprofundarmos no software, precisamos fazer algumas modificações no hardware.

Hardware

Um carro Magnet foi usado para o projeto Donkey Car. Magnet é um carro RC (controlado remotamente) que opera usando um rádio multicanal de 2,4 GHz. Para transformar o Magnet em um carro Donkey, há algumas etapas que devem ser executadas.

1. Desmontagem

Primeiro remova a tampa superior removendo os clipes e dois parafusos na parte traseira. Você encontrará uma gaiola com dois motoristas. Remova isso também e, em seguida, remova a gaiola superior externa. Agora você tem acesso aos circuitos do carro. De cima, uma vez pode-se ver o receptor, o ESC (Controlador Eletrônico de Velocidade) e o servo.


Um DonkeyCar

O receptor é um receptor de 4 canais com um circuito B / C (eliminação de bateria). Cada canal usa um conector de 3 fios. Os canais CH3 e CH4 não são usados. O ESC leva a bateria como entrada, chave de alimentação e a entrada do canal 1 do receptor. O servo é conectado ao canal 0 do receptor. O servo é usado para dirigir. O ângulo de direção pode ser ajustado manualmente se estiver dirigindo por meio de um joystick ou precisa ser calibrado.

2. Monte os adaptadores

Dois adaptadores de plástico impressos em 3D são usados, após remover os dois parafusos e a parte superior do corpo. Você tem que aparafusar os dois adaptadores no lugar dos clipes existentes usando os mesmos parafusos. Depois de substituir os dois clipes pelos dois adaptadores impressos em 3D, agora podemos montar a placa superior de madeira do carro Donkey.


Adaptadores que substituem os clipes longos

Em seguida, aparafuse a alça da câmera na placa da placa de base. Em seguida, coloque as peças roscadas de plástico em cada orifício. Eles são usados ​​para prender o Raspberry Pi e o servo controlador no lugar.

3. Servo controlador e RPi

Monte o RPi e o servo controlador na placa de madeira. Acabei usando zíperes para prender o RPi, pois não queria colocar um parafuso metálico perto da antena. Após aparafusar o servo controlador, conecte os pinos do barramento I2C do RPi ao servo controlador. Em seguida, pegue uma pequena faca e corte os laços que prendem o ESC e os fios de 3 pinos do servo.

Ao conectar ao servo controlador externo, ambas as conexões ao receptor devem ser desconectadas dele e conectadas aos canais 0 e 1 do servo controlador, que posteriormente montaremos no topo do DonkeyCar placa.

4. Placa de madeira

Monte a placa de madeira nos adaptadores. Agora use os clipes para prender a placa DonkeyCar aos adaptadores do chassi magnético.

Monte a placa do carro Donkey na parte superior e use um cabo USB curto para conectar a bateria USB ao RPi. Os cabos do acelerador e da direção se projetarão da abertura na placa e se conectarão aos canais 0 e 1 do servo controlador montado na placa do carro Donkey.

5. Sensores adicionais

O principal problema com a configuração padrão é que não há nenhum sensor usado para medir a velocidade ou distância aos obstáculos. Eu adicionei uma IMU 6DOF MPU6050 que permite ao RPi medir aceleração e curvas em 3D. Em seguida, adicionei um GPS à porta serial e também um sensor HCSR04 para medição de distância. O HCSR04, entretanto, funciona via 5V e precisa de um deslocador de nível.

Isso completa o estágio de hardware da unidade. O Donkey Car foi totalmente convertido em um veículo de 4 rodas equipado com:

a) Câmera monocular grande angular

b) Servo controlador.

c) Sensor 6-DOF IMU

d) GPS

e) Sensor de distância

Todos os sensores adicionais serão marcados com o tempo na aquisição e usados ​​para aumentar os vetores de treinamento para a rede neural profunda.

Para suportar o sensor extra, é necessário modificar o script manage.py para adicionar esta funcionalidade.

Para usar o IMU, inicialmente tentei uma biblioteca Python para FXOS8700 no Debian Stretch. Isso não funcionou fora da caixa devido ao bug de inicialização repetido do RPi, então acabei usando um MPU6050 que também vem com um giroscópio.

Para testar o código IMU, use o seguinte snippet abaixo:

da IMU import MPU6050
mu =MPU6050 ()
a =imu.run ()
a #print uma resposta

O seguinte software precisa ser de dentro do virtualenv para o MPU6050:

sudo apt install python3-smbus
pip install mpu6050-raspberrypi

O arquivo meta.json na pasta tub deve ser aumentado para suportar o registro de dados IMU.

{“Entradas”:[“cam / imagem_array”, “usuário / ângulo”, “usuário / acelerador”, “usuário / modo”, “imu / acl_x”, “imu / acl_y”, “imu / acl_z”, “imu / gyr_x ”,“ imu / gyr_y ”,“ imu / gyr_z ”],“ tipos ”:[“ image_array ”,“ float ”,“ float ”,“ str ”,“ float ”,“ float ”,“ float ”, “Float”, “float”, “float”]}

O arquivo manage.py também deve ser modificado conforme abaixo:

imu =Mpu6050 ()
V.add (imu, outputs =['imu / acl_x', 'imu / acl_y', 'imu / acl_z', 'imu / gyr_x', 'imu / gyr_y', 'imu / gyr_z '], threaded =True)
# adicionar banheira para salvar dados
inputs =[' cam / image_array ',' user / angle ',' user / throttle ',' user / mode ', 'imu / acl_x', 'imu / acl_y', 'imu / acl_z', 'imu / gyr_x', 'imu / gyr_y', 'imu / gyr_z']
types =['image_array', 'float' , 'float', 'str', 'float', 'float', 'float', 'float', 'float', 'float']

Finalmente, também adicionei um módulo GPS à unidade. Embora não possa ser usado em ambientes internos, é útil adicionar para testes externos em áreas onde você pode se conectar a uma rede WIFI.

Se for necessário registrar os dados do GPS, a mesma modificação do IMU deve ser implementada.

Para usar o sensor de distância HSCR04 uma vez, é necessário instalar a biblioteca RPI.GPIO do ambiente python.

pi p instalar RPi.GPIO

Isso resume todas as modificações de hardware. No final, você vai acabar com um DonkeyCar parecido com este:

Software

A ideia aqui é implementar um pipeline de AI para a detecção de objetos em execução no RPi. A primeira etapa será implantar um DNN de detecção de objeto que funcionará no RPi 3 sem dependência de dispositivos externos. Vamos começar instalando o software necessário.

1. Instale as bibliotecas DNN

O projeto usa TensorFlow e OpenCV. Em termos simples, para fazer inferências no Raspberry Pi usamos uma rede já treinada. Depois que os pesos são carregados, a detecção de objetos e a inferência são feitas para cada quadro de câmera.

pip instalar tensorflow [pi]
pip instalar matplotlib framboesa
sudo apt-get instalar libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
sudo apt-get instalar libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
sudo apt-get install libxvidcore-dev libx264-devsudo apt-get install qt4-dev-tools
pip3 install opencv-python

Uma coisa que precisa ser apontada é que o TensorFlow usa um formato de arquivo diferente, ao contrário do Keras, que tem um fluxo de trabalho relativamente simples para carregar pesos como arquivos h5.

sudo pip3 install keras - atualização

Clone o repositório oficial do modelo TensorFlow.

git clone –recurse-submodules https://github.com/tensorflow/models.git

e exporte o caminho:

exportar PYTHONPATH =$ PYTHONPATH:/ home / pi / tensorflow1 / models / research:/ home / pi / tensorflow1 / models / research / slim

Finalmente, quando tudo estiver instalado e antes de reiniciar o problema

desative #para sair da área de trabalho virtual env se estiver usando um
sudo shutdown -h now

A próxima etapa é instalar o compilador Protobuffer para os pesos do SSD MobileNetV2.

2. Instale o compilador ProtoBuffer

Keras usa um formato de arquivo diferente do TensorFlow. Portanto, temos que lidar com Protobuffers, que é o formato nativo do TensorFlow.

Instalei a versão 3.5.1

sudo apt-get install autoconf automake libtool curl
wget https://github.com/google/protobuf/releases/download/v3.5.1/protobuf-all–3.5.1.tar.gz
tar -zxvf protobuf-all – 3.5.1.tar.gzcd protobuf-3.5.1
./configure

Compilar isso levará um pouco de tempo (~ 1,5 h) no RPi. A outra solução é a compilação cruzada, mas teremos que mantê-la simples por enquanto. Emitir:

faça

Em seguida, emita:

make check
sudo make install
cd pythonexport
LD_LIBRARY_PATH =.. / src / .libs

Finalmente instale o compilador:

python3 setup.py build –cpp_implementation python3 setup.py test –cpp_implementationsudo python3 setup.py install –cpp_implementation

Agora exporte o caminho:

exportar PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION =cpp
exportar PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION =3
sudo ldconfig

Finalmente, para testar o compilador, basta digitar:

protoc

Agora estamos prontos para fazer barulho. Isso nos permitirá converter o peso em um formato que o TensorFlow entenda.

Leia mais detalhes:IA de direção autônoma para coletor de lixo Donkey Car