Autonoom rijden AI voor vuilniswagen van ezels

Gebruik een TensorFlow SSD MobileNetV2 DNN op de Raspberry Pi plus Pi-camera om een ​​autonome auto te bouwen die objectdetectie kan uitvoeren.

Verhaal

Dit project laat zien hoe een (Raspberry Pi + Pi-camera) aangedreven RC-auto kan worden getransformeerd in een auto die object kan detecteren en autonoom kan rijden. Om dit te doen zullen we twee diepe neurale netwerken inzetten. Een voor objectdetectie en de andere voor autonoom rijden met behulp van inferentie voor sturen en gas geven. Een RPi 3 dient als voertuigcomputer. Vanwege beperkte middelen op de RPi kan slechts één van de netwerken tegelijk worden uitgevoerd.

Het idee is om het neurale netwerk te trainen om vuilnisbakken te identificeren, zodat de auto ze autonoom kan oppakken.

auto en laptop identificeren

Het project bestaat uit twee delen. In het eerste deel is het de bedoeling om een ​​convolutienetwerk van gemiddelde grootte te gebruiken om objecten in de invoervideofeed van de Pi-camera te herkennen. TensorFlow wordt gebruikt om het CNN-model in te zetten en OpenCV wordt gebruikt voor het beheren van de videofeed van de Pi-camera.

In het tweede deel gaan we gedragsklonen gebruiken om de auto autonoom te laten navigeren. De aangepaste auto zal ook worden uitgebreid met extra sensoren zoals een ultrasone afstandssensor, GPS en 6-DOF IMU, evenals aanvullende telemetriefuncties.

Inleiding

In 2017 (een jaar geleden) bracht Google MobileNet uit, en eerder dit jaar MobileNetV2. Deze netwerken zijn op maat geoptimaliseerd voor het werken op embedded apparaten zoals smartphones. Toevallig valt de MPU die op RPi 3 wordt gebruikt in deze categorie omdat hij zowel Linux als Android kan draaien.

Het eerste probleem dat men tegenkomt is het beperkte RAM-geheugen en de beperkte rekencapaciteit van Raspberry Pi 3. Hoewel dit een quad-core MPU is, is het nog steeds niet genoeg als het gaat om enorme gewichtsbestanden die YOLO nodig heeft (You Only Look Once) type netwerken.

De eerste oplossing die in je opkomt, is om het beeld dat via de Pi-camera is verkregen via WIFI naar een externe pc te sturen en daar de objectinferentiefase uit te voeren en vervolgens opdrachten naar de Donkey Car te sturen. In wezen moeten we bij elke stap contact opnemen met het moederschip. Dit is inefficiënt om nog maar te zwijgen van onpraktisch in scenario's waarin communicatie met een externe laptop niet mogelijk is.

Ik heb aanvankelijk een VGG16-netwerk getest dat relatief nauwkeurig was bij het detecteren van vuilnisbakken. Het kon echter niet op de RPi draaien, aangezien het gewicht alleen al rond de 350 MB was! Raadpleeg de bijgevoegde code aan het einde met soortgelijke afbeeldingen als invoer om het VGG-netwerk te testen.

Probleem:

python KerasVGG_test.py

Dus om het probleem van enorme gewichten op te lossen, gaan we alle modellen op de RPi draaien met behulp van slankere netwerken. Specifiek gaan we de op MobileNetV2 Single Shot Detector gebaseerde CNN gebruiken. Dit is een DNN die is geoptimaliseerd om zeer kleine (relatief) gewichten te hebben.

De techniek wordt transfer learning genoemd omdat we een vooraf getraind netwerkgewicht gebruiken.

Voordat we in de software duiken, moeten we enkele hardwareaanpassingen maken.

Hardware

Voor het Donkey Car-project werd een magneetauto gebruikt. Magnet is een RC-auto (op afstand bestuurbaar) die werkt met een 2,4 GHz meerkanaals radio. Om de magneet in een ezelwagen te veranderen, moeten er een aantal stappen worden ondernomen.

1. Demontage

Verwijder eerst de bovenklep door de clips en twee schroeven aan de achterkant te verwijderen. Je vindt er een kooi met twee chauffeurs. Verwijder deze ook en verwijder vervolgens de buitenste bovenste kooi. Nu heb je toegang tot de circuits op de auto. Van bovenaf zie je eenmaal de ontvanger, de ESC (elektronische snelheidsregelaar) en de servo.

Een kale DonkeyCar

De ontvanger is een 4-kanaals ontvanger met een B/C-schakeling (batterij-eliminatie). Elk kanaal maakt gebruik van een 3-draads connector. Kanalen CH3 en CH4 worden niet gebruikt. De ESC neemt de batterij als ingang, aan/uit-schakelaar en de ingang van de ontvanger kanaal 1. De servo wordt aangesloten op kanaal 0 van de ontvanger. De servo wordt gebruikt om te sturen. De stuurhoek kan handmatig worden getrimd als er met een joystick wordt gereden of moet worden gekalibreerd.

2. Monteer de adapters

Er worden twee 3D-geprinte plastic adapters gebruikt, nadat de twee schroeven en de bovenkant van de behuizing zijn verwijderd. Je moet de twee adapters in plaats van de bestaande clips vastschroeven met dezelfde schroeven. Na het vervangen van de twee clips door de twee 3D geprinte adapters kunnen we nu de bovenste houten Donkey car plaat monteren.

Adapters die de lange clips vervangen

Schroef vervolgens de camerahendel op de bodemplaat vast. Plaats vervolgens de kunststof schroefdraaddelen op elk gat. Deze worden gebruikt om de Raspberry Pi en de servocontroller op hun plaats te houden.

3. Servocontroller en RPi

Monteer de RPi en de servocontroller op de houten plaat. Ik heb uiteindelijk kabelbinders gebruikt om de RPi vast te zetten, omdat ik geen metalen schroef in de buurt van de antenne wilde plaatsen. Sluit na het vastschroeven van de servocontroller de I2C-buspinnen van de RPi aan op de servocontroller. Neem vervolgens een klein mes en knip de kabelbinders door die de ESC- en servo 3-pins draden bij elkaar houden.

Bij aansluiting op de externe servocontroller moeten beide verbindingen met de ontvanger worden losgekoppeld en aangesloten op kanalen 0 en 1 van de servocontroller die we later op de DonkeyCar-top- zullen monteren. bord.

4. Houten plaat

Monteer de houten plaat op de adapters. Gebruik nu de clips om de DonkeyCar-plaat aan de Magnet Chassis-adapters te bevestigen.

Monteer de Donkey-autoplaat erop en gebruik een korte USB-kabel om de USB-batterij op de RPi aan te sluiten. De gas- en stuurkabels steken uit de opening in de plaat en worden aangesloten op kanaal 0 en 1 van de servocontroller die op de plaat van de ezelwagen is gemonteerd.

5. Extra sensoren

Het belangrijkste probleem met de standaardconfiguratie is dat er geen sensor wordt gebruikt om de snelheid of afstand tot obstakels te meten. Ik heb een 6DOF MPU6050 IMU toegevoegd waarmee de RPi 3D-versnelling en bochten kan meten. Vervolgens heb ik een GPS toegevoegd aan de seriële poort en ook een HCSR04-sensor voor afstandsmeting. De HCSR04 werkt echter via 5V en heeft een level shifter nodig.

Dit voltooit de hardwarefase van het apparaat. De Donkey Car is volledig omgebouwd tot een vierwielig voertuig uitgerust met:

a) Monoculaire groothoekcamera

b) Servocontroller.

c) 6-DOF IMU-sensor

d) GPS

e) Afstandssensor

Alle extra sensoren worden bij acquisitie voorzien van een tijdstempel en worden gebruikt om de trainingsvectoren voor het diepe neurale netwerk te vergroten.

Om de extra sensor te ondersteunen, moet je het manage.py -script aanpassen om deze functionaliteit toe te voegen.

Om de IMU te gebruiken, probeerde ik aanvankelijk een Python-bibliotheek voor FXOS8700 op Debian Stretch. Dit werkte niet uit de doos vanwege de herhaalde startbug van de RPi, dus ik heb uiteindelijk een MPU6050 gebruikt die ook wordt geleverd met een gyroscoop.

Gebruik het volgende fragment hieronder om de IMU-code te testen:

van IMU importeer MPU6050
mu =MPU6050()
a =imu.run()
een #print antwoord

De volgende software moet uit de virtualenv voor de MPU6050 komen:

sudo apt install python3-smbus
pip install mpu6050-raspberrypi

Het bestand meta.json onder de tub-map moet worden uitgebreid om het loggen van IMU-gegevens te ondersteunen.

{“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", “zweven”, “zweven”, “zweven”]}

Het bestand manage.py moet ook als volgt worden gewijzigd:

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)
# voeg tub toe om gegevens op te slaan
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']

Eindelijk heb ik ook een GPS-module aan het apparaat toegevoegd. Hoewel dit niet binnenshuis kan worden gebruikt, is het handig om het toe te voegen voor buitentests in gebieden waar u verbinding kunt maken met een wifi-netwerk.

Als men GPS-gegevens moet inloggen, moet dezelfde wijziging als bij de IMU worden doorgevoerd.

Als u de HSCR04-afstandssensor eenmaal wilt gebruiken, moet u de RPI.GPIO-bibliotheek uit de python-omgeving installeren.

pi p installeer RPi.GPIO

Dit vat alle hardware-aanpassingen samen. Uiteindelijk krijg je een DonkeyCar die er zo uitziet:

Software

Het idee hier is om een ​​AI-pipeline voor objectdetectie te implementeren die op de RPi wordt uitgevoerd. De eerste stap is het implementeren van een objectdetectie-DNN dat op de RPi 3 werkt zonder afhankelijkheid van externe apparaten. Laten we beginnen door de benodigde software te installeren.

1. Installeer DNN-bibliotheken

Het project gebruikt TensorFlow en OpenCV. In eenvoudige bewoordingen gebruiken we een reeds getraind netwerk om gevolgtrekkingen te maken op de Raspberry Pi. Nadat de gewichten zijn geladen, wordt objectdetectie en inferentie gedaan voor elk cameraframe.

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

Eén ding dat moet worden opgemerkt, is dat TensorFlow een ander bestandsformaat gebruikt in tegenstelling tot Keras, dat een relatief eenvoudige workflow heeft voor het laden van gewichten als h5-bestanden.

sudo pip3 install keras –upgrade

Kloon de officiële TensorFlow-modelrepository.

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

en exporteer het pad:

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

Eindelijk wanneer alles is geïnstalleerd en voordat u het probleem opnieuw opstart

deactiveer #om uit de virtuele env-werkruimte te komen als u er een gebruikt
sudo shutdown -h now

De volgende stap is het installeren van de Protobuffer-compiler voor de gewichten van de MobileNetV2 SSD.

2. Installeer de ProtoBuffer-compiler

Keras gebruikt een ander bestandsformaat dan TensorFlow. We hebben dus te maken met Protobuffers, het oorspronkelijke formaat voor TensorFlow.

Ik heb versie 3.5.1 geïnstalleerd

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

Het compileren hiervan kost behoorlijk wat tijd (~1,5 uur) op de RPi. De andere oplossing is om te cross-compileren, maar we zullen het voorlopig simpel moeten houden. Probleem:

maken

Vervolgens:

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

Installeer eindelijk de compiler:

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

Exporteer nu het pad :

export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=cpp
export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION_VERSION=3
sudo ldconfig

Ten slotte om de compiler te testen typ je:

protocol

Nu worden we gelezen om te rommelen. Dit stelt ons in staat om het gewicht om te zetten in een formaat dat TensorFlow begrijpt.

Lees meer details:Autonoom rijden AI voor Donkey Car Garbage Collector