AI de conducción autónoma para el recolector de basura de burro

Usa un SSD de TensorFlow MobileNetV2 DNN en la cámara Raspberry Pi plus Pi para construir un automóvil autónomo capaz de detectar objetos.

Historia

Este proyecto mostrará cómo transformar un automóvil RC impulsado (Raspberry Pi + Pi Camera) en uno capaz de detección de objetos y conducción autónoma. Para ello, desplegaremos dos redes neuronales profundas. Uno para la detección de objetos y el otro para la conducción autónoma mediante inferencia para la dirección y el acelerador. Un RPi 3 sirve como computadora del vehículo. Debido a los recursos limitados en el RPi, solo una de las redes puede ejecutarse a la vez.

La idea es entrenar la red neuronal para identificar los contenedores de basura para que el automóvil pueda recogerlos de forma autónoma.

identificación del automóvil y la computadora portátil

El proyecto consta de dos partes. En la primera parte, el plan es utilizar una red convolucional de tamaño moderado para reconocer objetos en la alimentación de video de entrada de la cámara Pi. TensorFlow se usará para implementar el modelo CNN y OpenCV se usará para administrar la transmisión de video desde la cámara Pi.

En la segunda parte usaremos la clonación conductual para que el automóvil navegue de forma autónoma. El automóvil modificado también se verá reforzado con sensores adicionales, como el sensor de distancia ultrasónico, GPS e IMU de 6 DOF, además de implementar funciones de telemetría adicionales.

Introducción

En 2017 (hace un año), Google lanzó MobileNet y, a principios de este año, MobileNetV2. Estas redes están optimizadas a medida para trabajar en dispositivos integrados como teléfonos inteligentes. Casualmente, la MPU utilizada en RPi 3 entra en esta categoría, ya que puede ejecutar Linux o Android.

El primer problema que uno encuentra es la RAM limitada y la capacidad computacional de Raspberry Pi 3. Aunque esta es una MPU de cuatro núcleos, todavía no es suficiente cuando se trata de archivos de peso masivos que necesita YOLO (solo usted Mira una vez) escribe redes.

La primera solución que me viene a la mente es enviar la imagen adquirida a través de la Pi Camera a través de WIFI a una PC externa y hacer allí la etapa de inferencia de objetos y luego enviar comandos al Donkey Car. En esencia, tenemos que ponernos en contacto con la nave nodriza en cada paso, lo que es ineficiente, por no mencionar que es poco práctico en situaciones en las que la comunicación con una computadora portátil externa no es posible.

Inicialmente probé una red VGG16 que era relativamente precisa al detectar contenedores de basura. Sin embargo, no se pudo ejecutar en el RPi ya que solo los pesos eran de alrededor de 350 MB. Para probar la red VGG, consulte el código adjunto al final con imágenes similares como entrada.

Problema:

python KerasVGG_test.py

Entonces, para resolver el problema de los tamaños de pesos enormes, vamos a ejecutar todos los modelos en el RPi utilizando redes más delgadas. Específicamente, vamos a utilizar la CNN basada en el detector de disparo único MobileNetV2. Este es un DNN que se ha optimizado para tener pesos muy pequeños (relativamente).

La técnica se llama aprendizaje de transferencia ya que estamos usando una red de pesos previamente entrenados.

Antes de profundizar en el software, tenemos que hacer algunas modificaciones de hardware.

Hardware

Se usó un carro Magnet para el proyecto Donkey Car. Magnet es un automóvil RC (controlado a distancia) que funciona con una radio multicanal de 2.4GHz. Para transformar el imán en un coche burro, hay que seguir un par de pasos.

1. Desmontaje

Primero retire la cubierta superior quitando los clips y dos tornillos en la parte posterior. Encontrarás una jaula con dos conductores. Quita esto también y luego quita la caja superior exterior. Ahora tienes acceso a los circuitos en el auto. Desde la parte superior una vez se puede ver el receptor, el ESC (controlador electrónico de velocidad) y el servo.

Un DonkeyCar desnudo

El receptor es un receptor de 4 canales con un circuito B / C (eliminación de batería). Cada canal utiliza un conector de 3 cables. Los canales CH3 y CH4 no se utilizan. El ESC toma la batería como entrada, interruptor de encendido y la entrada del canal 1 del receptor. El servo está conectado al canal 0 del receptor. El servo se utiliza para la dirección. El ángulo de dirección se puede ajustar manualmente si se conduce con un joystick o si se tiene que calibrar.

2. Monte los adaptadores

Se utilizan dos adaptadores de plástico impresos en 3D, después de quitar los dos tornillos y la parte superior del cuerpo. Tienes que atornillar los dos adaptadores en lugar de los clips existentes usando los mismos tornillos. Después de reemplazar los dos clips con los dos adaptadores impresos en 3D, ahora podemos montar la placa superior de madera del coche Donkey.

Adaptadores que reemplazan los clips largos

A continuación, atornille el asa de la cámara en la placa de la placa base. Luego, coloque las piezas roscadas de plástico en cada orificio. Se utilizan para asegurar la Raspberry Pi y el servocontrolador en su lugar.

3. Servocontrolador y RPi

Monte el RPi y el servocontrolador en la placa de madera. Terminé usando bridas para asegurar el RPi ya que no quería poner un tornillo metálico cerca de la antena. Después de atornillar el servocontrolador, conecte los pines del bus I2C del RPi al servocontrolador. A continuación, tome un cuchillo pequeño y corte las bridas que sujetan el ESC y los cables de 3 pines del servo.

Cuando se conecta al servocontrolador externo, ambas conexiones al receptor deben desconectarse del mismo y conectarse a los canales 0 y 1 del servocontrolador que luego montaremos en la parte superior del DonkeyCar. plato.

4. Plato de madera

Monte la placa de madera en los adaptadores. Ahora use los clips para sujetar la placa DonkeyCar a los adaptadores del chasis magnético.

Monte la placa del auto Donkey en la parte superior y use un cable USB corto para conectar la batería USB al RPi. Los cables del acelerador y de la dirección sobresaldrán de la abertura de la placa y se conectarán al canal 0 y 1 del servocontrolador montado en la placa del coche Donkey.

5. Sensores adicionales

El principal problema con la configuración estándar es que no se utiliza ningún sensor para medir la velocidad o la distancia a los obstáculos. Agregué una IMU 6DOF MPU6050 que permite al RPi medir la aceleración 3D y los giros. Luego agregué un GPS al puerto serie y también un sensor HCSR04 para medir la distancia. Sin embargo, el HCSR04 funciona a través de 5V y necesita un cambiador de nivel.

Esto completa la etapa de hardware de la unidad. El Donkey Car se ha convertido por completo en un vehículo de 4 ruedas equipado con:

a) Cámara gran angular monocular

b) Servocontrolador.

c) Sensor IMU 6-DOF

d) GPS

e) Sensor de distancia

Todos los sensores adicionales tendrán una marca de tiempo en el momento de la adquisición y se usarán para aumentar los vectores de entrenamiento para la red neuronal profunda.

Para admitir el sensor adicional, uno tiene que modificar el script manage.py para agregar esta funcionalidad.

Para usar la IMU, inicialmente probé una biblioteca de Python para FXOS8700 en Debian Stretch. Esto no funcionó de inmediato debido al error de inicio repetido del RPi, por lo que terminé usando un MPU6050 que también viene con un giroscopio.

Para probar el código IMU, use el siguiente fragmento a continuación:

desde IMU import MPU6050
mu =MPU6050 ()
a =imu.run ()
a #print answer

El siguiente software debe ser de virtualenv para el MPU6050:

sudo apt install python3-smbus
pip install mpu6050-raspberrypi

El archivo meta.json debajo de la carpeta tub debe aumentarse para admitir el registro de datos de IMU.

{"Entradas":["cam / image_array", "usuario / ángulo", "usuario / acelerador", "usuario / 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 ”, "Flotar", "flotar", "flotar"]}

El archivo manage.py también debe modificarse de la siguiente manera:

imu =Mpu6050 ()
V.add (imu, salidas =['imu / acl_x', 'imu / acl_y', 'imu / acl_z', 'imu / gyr_x', 'imu / gyr_y', 'imu / gyr_z '], hilo =True)
# agregar bañera para guardar datos
entradas =[' cam / image_array ',' usuario / ángulo ',' usuario / acelerador ',' usuario / modo ', 'imu / acl_x', 'imu / acl_y', 'imu / acl_z', 'imu / gyr_x', 'imu / gyr_y', 'imu / gyr_z']
tipos =['image_array', 'float' , 'flotar', 'str', 'flotar', 'flotar', 'flotar', 'flotar', 'flotar', 'flotar']

Finalmente también agregué un módulo GPS a la unidad. Si bien no se puede usar en interiores, es útil agregarlo para pruebas al aire libre en áreas donde puede conectarse a una red WIFI.

Si se necesita iniciar sesión en datos GPS, se debe implementar la misma modificación que con la IMU.

Para usar el sensor de distancia HSCR04 una vez, debe instalar la biblioteca RPI.GPIO desde el entorno de Python.

pi p instalar RPi.GPIO

Esto resume todas las modificaciones de hardware. Al final, terminarás con un DonkeyCar que se ve así:

Software

La idea aquí es implementar una canalización de IA para la detección de objetos que se ejecuta en el RPi. El primer paso será implementar un DNN de detección de objetos que funcionará en el RPi 3 sin depender de dispositivos externos. Comencemos instalando el software necesario.

1. Instale las bibliotecas DNN

El proyecto usa TensorFlow y OpenCV. En términos simples, para hacer inferencias en la Raspberry Pi usamos una red ya entrenada. Una vez que se cargan los pesos, se realiza la detección de objetos y la inferencia para cada fotograma de la cámara.

pip install tensorflow [pi]
pip install matplotlib raspberry
sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
sudo apt-get install 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

Una cosa que debe señalarse es que TensorFlow usa un formato de archivo diferente a diferencia de Keras, que tiene un flujo de trabajo relativamente simple para cargar pesos como archivos h5.

sudo pip3 install keras –upgrade

Clona el repositorio de modelos oficial de TensorFlow.

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

y exportar la ruta:

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

Finalmente, cuando todo esté instalado y antes de reiniciar el problema

desactive #para salir del espacio de trabajo del entorno virtual si está usando un
sudo shutdown -h now

El siguiente paso es instalar el compilador Protobuffer para los pesos del SSD MobileNetV2.

2. Instale el compilador ProtoBuffer

Keras usa un formato de archivo diferente al de TensorFlow. Entonces tenemos que lidiar con Protobuffers, que es el formato nativo de TensorFlow.

Instalé la versión 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 esto llevará bastante tiempo (~ 1,5 horas) en el RPi. La otra solución es la compilación cruzada, pero tendremos que mantenerlo simple por ahora. Problema:

hacer

Luego emita:

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

Finalmente instala el compilador:

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

Ahora exporte la ruta:

exportar PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION =cpp
exportar PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION =3
sudo ldconfig

Finalmente, para probar el compilador, simplemente escriba:

protocolo

Ahora estamos leídos para retumbar. Esto nos permitirá convertir el peso a un formato que comprenda TensorFlow.

Leer más detalles:IA de conducción autónoma para el recolector de basura de burro