Autonom fahrendes Raspberry Pi KI Roboter-Auto – Donkeycar training in einem Docker Container

Da ich gerne das Training auf einem professionellen Rechner für Maschinenlernen mit mehreren nVidia GPUs durchführen möchte musste ich das Donkeycar Framework in einem Docker Container unterbringen. Anders wäre das in diesem Fall leider nicht gegangen da ich lokal nichts installieren darf. Daher ist diese Beschreibung nur für Leser interessant die z. B. auf Servern einer Firma das Donkey Car Framework installieren möchten. Um dieser Anforderung gerecht zu werden habe ich mich in Docker eingearbeitet und mein individuelles Docker Image erstellt. Das Dockerfile das ich mir dazu aufgebaut habe ist “noch” eine Lösung für die Berechnung mit einer CPU und verwendet daher nicht die Tensorflow Installation für eine GPU. Diesen Schritt im Image muss ich noch vorsehen sobald ich die genaueren Eckdaten des Rechners habe und die Information welche Treiber genau von nVIDIA eingebunden werden müssen.

Als Host habe ich Ubuntu 18.04 verwendet und diese Ubuntu Version auch für den Aufbau meines Images hergenommen. Einen extra Client hatte ich nicht im Einsatz. Ich habe alles auf meinem Laptop installiert der somit Host und Client in einem war.

Damit die Steuerung des Donkeycar Frameworks im Container individuell durchgeführt werden kann habe ich mir mit flask ein kleines minimalistisches Web-Interface gebaut. Über dieses Web-Interface ist es mir möglich Parameter für das Training des neuronalen Netzes in den Container zu senden und das Training individuell parametrisiert auszuführen.

Das folgende Bild zeigt den aktiven Container der gerade trainiert und im Hintergrund das Web-Interface. Über dieses wurde das Training angestoßen.

Donkeycar2 Docker Container training

Inhaltsverzeichnis

Dockerfile @Donkeycar training

Jetzt geht es aber ersteinmal mit dem wichtigsten dem Dockerfile los. Das Dockerfile habe ich hier bereitgestellt und freue mich natürlich über Hinweise und Tipps da es mein erster eigener Versuch mit dieser Technologie ist.

FROM ubuntu:18.04
MAINTAINER Ingmar Stapel
LABEL version=”0.9″
LABEL description=”First image with donkeycar2 and flask”

# Update the image with the latest stuff
RUN apt-get -y update
RUN apt-get -y upgrade
RUN apt-get -y install git
RUN apt-get -y install python3-pip
RUN pip3 install –upgrade pip

# To use a web interface to control the calculation process.
RUN pip3 install flask

# install all we need to run the donkeycar2 framework
RUN pip3 install numpy
RUN pip3 install tensorflow==1.8.0
RUN pip3 install keras –upgrade

# Create the working direcotry for the donkeycar project itself inside the docker image
RUN mkdir -p /donkeydocker

# set the workdir variable
ENV V_WD /donkeydocker

# set the workdir to the cloned donkeycar git repo
WORKDIR $V_WD

# clone the donkeycar2 master from github outside the docker image into the parent directory.
# Attention: Change the destination path and do not use my home path /home/ingmar….
# git clone -b master https://github.com/wroscoe/donkey /home/ingmar/donkeydocker/git
# Copy the already cloned git donkeycar repo into the file structure of the docker image.
# Descritpion of the COPY command: COPY <src> <dest>
COPY . $V_WD

# install the donkeycar framework inside the docker image
RUN pip3 install -e .

# create a mycar in the folder /donkeydocker/mycar with all the needed scripts
RUN donkey createcar $V_WD/mycar

# flask web server port to show up the user interface
EXPOSE 8181

# run the flask server to start up the web user interface
ENTRYPOINT [“python3”, “/donkeydocker/flask/master.py”]

.dockerignore File

Damit nicht sämtliche Dateien aus dem Ordner “donkey4docker” im Image landen können mit einem .dockerignore File Ausnahmen von Dateien und Ordner festgelegt werden. Dazu schreibt man einfach die Namen der Dateien oder Ordner in das file selber.

Beispiel:

data_training

Gut zu wissen

Ich gehe nicht weiter auf das Dockerfile oder Docker als solches ein. Um überhaupt Docker und dieses Dockerfile zu verstehen und erstellen zu können habe ich viel gelesen wie z. B. die beiden folgenden Bücher. Nachfolgend zwei Verweise auf die Amazon Onlineshop Seite.

Loading ...

Docker Befehle

Aber zu erst muss das Image gebaut werden. Dazu gehe ich davon aus, dass alle Dateien also das Donkeycar Projekt, das Dockerfile und die Dateien des Web-Interfaces im Ordner “/home/ingmar/donkey4docker/” liegen. Der Befehl um das Image zu bauen sieht bei mir wie folgt aus. Auch wird davon ausgegangen, das alle nachfolgenden Befehle genau in diesem Pfad über das Terminal Fenster ausgeführt werden.

Befehl:

sudo docker build -t my_image_08 .

Nach dem das Image gebaut ist muss noch das lokale Laufwerk eingebunden werden. Dazu habe ich den folgenden Befehl ausgeführt der ein Docker Volumen auf meinem Host erstellt. Dieses Volumen hat den Namen “data_training” und wird im Ordner “/home/ingmar/donkey4docker” angelegt in dem ich mich zum Zeitpunkt des ausführend im Terminal Fenster befunden habe. In diesem Ordner sollen dann später die aufgenommenen TUB* Ordner mit den Trainingsdaten abgelegt werden. Auch wird hier das fertig trainierte Modell gespeichert.

Befehl:

sudo docker volume create –name data_training

Der Startbefehl um das fertige Image auszuführen sieht bei mir wie folgt aus. Mit diesem werden die Ports für das Web-Interface freigegeben und auch das Docker Volumen eingebunden.

Befehl:

sudo docker run -i -t -p 8181:8181 -v ~/donkey4docker/data_training/:/donkeydocker/mycar/data my_image_08

Flask Web-Interface

Wie man schon im Dockerfile unschwer erkennen konnte habe ich Flask als Web-Server verwendet. Dieser führt ein minimalistisches Web-Template die index.html Datei aus. Über diese kann ein Befehl in den Container gesendet werden der dann entsprechend das Donkeycar Training an startet.

Donkeycar Docker Web Interface

Die Dateien für das Web-Interface wurden in einer ganz einfachen für Flask typischen Ordnerstruktur abgelegt. Dabei besteht es aus der “master.py” Python Datei mit der Programmlogik und der index.html Datei die das Web-Interface darstellt. Die Ordner Struktur sieht dann wie folgt mit flask als oberster Ordner und den zwei Unterordnern static und templates. Im Ordner flask liegt die “master.py” Datei und im Unterordner templates liegt die “index.html” Datei. Der Ordner static ist aktuell noch leer.

Ordnersturktur:

flask
- master.py
- static
- templates
  - index.html

master.py Programm Datei

Das Python Programm “master.py” selber ist recht kurz gehalten. Es führt den Job für das Training im Hintergrund aus. So können parallel auch mehrere Jobs gestartet werden. Das ist in meinem Fall für ein Training bzw. Wettbewerb sehr wichtig. Denn hier haben wir nur einen großen Rechner mit einer Vielzahl an NVIDA Karten der die Modelle für alle Teams berechnen soll. Das Programm selber sieht und sieht wie folgt aus:

#!/usr/bin/python3
from flask import Flask
from flask import render_template, url_for, request

import os

app = Flask(__name__)

@app.route(‘/’, methods=[‘GET’, ‘POST’])
def index():
return render_template(‘index.html’)

@app.route(‘/train’, methods=[‘GET’, ‘POST’])
def train():
if request.method ==’POST’:
cmd = request.form[‘cmd’]
# Try to get the name of the model
words = cmd.split(“/”)
# os.system(“python3 /donkeydocker/mycar/manage.py train “+ str(cmd))
# Read the last element of the list to get the model name to use it as name for the log file.
os.system(“python3 /donkeydocker/mycar/manage.py train “+ str(cmd)+” >> /donkeydocker/mycar/data/”+str(words[-1])+”.log 2>&1 &”)
return render_template(‘index.html’)

if __name__ == ‘__main__’:
app.run(host=’0.0.0.0′, port=8181, debug=False)

index.html Datei

Die HTML Datei “index.html” selber ist auch nicht sehr groß und sieht wie folgt aus:

<!doctype html>
<html>
<body>
<form action = “http://localhost:8181/train” method = “post”>
<h1><b>Enter donkeycar2 trainng command:</b></h1>
<h2 id=”train-a-model”>Train a model example from http://docs.donkeycar.com/guide/train_autopilot/</h2>
<ul>
<li>In the same terminal you can now run the training script on the latest tub by passing the path to that tub as an argument. You can optionally pass path masks, such as <code>./data/*</code> or <code>./data/tub_?_17-08-28</code> to gather multiple tubs. For example:</li>
</ul>
<pre><code class=”bash”>–tub <tub folder names comma separated> –model ./models/mypilot
</code></pre>

<p>Optionally you can pass no arguments for the tub, and then all tubs will be used in the default data dir.</p>
<pre><code class=”bash”>–model ~/mycar/models/mypilot</code></pre>
<p>This is the command I used:</p>
<pre><code class=”bash”>–model /donkeydocker/mycar/data/mypilot_x</code></pre>
<p><input type = “text” name = “cmd” /></p>
<p><input type = “submit” value = “start training” /></p>
</form>
</body>
</html>

Zusammenfassung

Mit diesem Docker Image bin ich jetzt in der Lage bzw. habe ich mir die Basis geschaffen ganz einfach Images für verschiedene Anwendungsfälle zu erstellen. Ich bin schon sehr gespannt wie aktiv ich dieses Wissen einsetzen werde. Es hängt sicher auch davon ab wie viel Zeit ich finden werde mich mit dem Donkeycar weiter zu beschäftigen.