© missisya, 123RF

Linux-Magazin-Autor Alexis Duque bringt Deep Learning dorthin, wo sein Gemüse wächst: in eine Vertical Farm. Er lässt eine abgespeckte Variante von Tensorflow vor Ort prognostizieren, wann der angebaute Salat erntereif ist.

Maschinelles Lernen hat das Computer-Paradigma verändert: Künstliche Intelligenz ist heute ein zentrales Merkmal beim Bau von Produkten. Die Konsumenten erwarten beim Gebrauch ihrer Geräte zunehmend Automatisierung und eine auf Menschen abgestimmte Interaktion.

Allerdings beschränkt sich die Deep-Learning-Revolution größtenteils auf die Cloud. Erst vor kurzem wurden dank der steigenden Performance von Mikrocontrollern und Embedded-Geräten mehrere Machine-Learning-Bibliotheken vorgestellt, die auf Edge-Geräten laufen und die Berechnungen an die Netzwerkperipherie verschieben. Das trifft auch auf Tensorflow Lite zu.

Tatsächlich brauchen Entwickler für das Aufbauen und Trainieren künstlicher neuronaler Netze zugkräftige Server mit GPUs und TPUs, während das Ausführen weniger Ressourcen erfordert und sich am Edge erledigen lässt. Das erlaubt es Entwicklern, ihre IoT-Geräte mit KI auszustatten, die verschiedene Aufgaben löst, darunter Anomalie- und Spracherkennung oder Regressionsanalyse.

Auf diesem Weg lässt sich eine Voraussage unabhängig von einer Cloud oder drahtlosen Verbindung treffen. Edge-Computing skaliert deutlich besser, weil sich die Kosten auf die Endgeräte verteilen, statt sich in der Cloud zu zentralisieren. Für einige Einsatzfälle, etwa die Spracherkennung, verbessert KI in der Netzwerkperipherie die Privatsphäre, weil die persönlichen Daten auf dem Gerät zu Hause oder im Büro verbleiben.

Optimale Ernte

Der vorliegende Artikel zeigt den Einsatz von Tensorflow Lite [1] auf IoT-Geräten. Konkret geht es um Vertical Farming. Maschinelles Lernen und künstliche Intelligenz helfen hier dabei, den Gemüseertrag zu optimieren oder das Erntedatum für die Pflanzen vorherzusagen.

Am Anfang führt der Artikel kurz das Konzept hinter Vertical Farming ein, bevor er sich Tensorflow Lite zuwendet und erklärt, wie es sich vom klassischen Tensorflow unterscheidet. Anschließend stelle ich die vernetzte Vertical Farm vor, die wir betreiben, und erläutere, warum und wie wir Tensorflow Lite verwenden.

Der Hauptteil beschäftigt sich sich schließlich in einem Tutorial damit, wie wir mit Tensorflow ein Wachstumsmodell für Salat entwerfen und trainieren, um dieses dann für die Netzwerkperipherie zu optimieren. Am Ende transferieren wir dieses schlankere Modell auf das Edge-Gerät, um das Erntedatum für den Salat mithilfe von Tensorflow Lite vorherzusagen. Der Artikel schließt mit meinen Gedanken zu Tensorflow Lite und liefert Feedback zu unseren gewonnenen Erkenntnissen.

Über Vertical Farming

Bei Vertical Farming handelt es sich um eine neue Methode, um Nutzpflanzen in einer komplett kontrollierten Umgebung in vertikal angeordneten Ebenen anzubauen. Vertical Farming will auf diese Weise nicht nur den Wasserverbrauch minimieren. Es zielt zudem darauf ab, die Produktivität zu erhöhen, indem es die Nutzpflanzen ohne Erde in geringen Mengen von nährstoffreichem Wasser platziert und in einem klimakontrollierten Glasschrank stapelt.

Vertical Farming könnte dabei helfen, den wachsenden globalen Nahrungsmittelbedarf auf nachhaltige Weise zu befriedigen. Es kann die Verteilungskette verkürzen und frischen Salat und Gemüse in die Nähe der Konsumenten bringen. Das verringert die Emissionen und erzeugt nährstoffreichere Produkte, die besser aussehen und schmecken.

In den letzten fünf Jahren haben viele Unternehmen damit begonnen, Vertical-Farming-Systeme zu entwickeln. Dafür setzen sie unterschiedliche Strukturen ein, wie etwa Frachtcontainer, Gebäude, Tunnel oder schrankartige Gehäuse wie das System, das ich in diesem Artikel vorstelle (Abbildung 1).

Abbildung 1: Die vertikale Farm verwendet einen Glasschrank als Gewächshaus. Diverse Sensoren überwachen die Salatproduktion.

Im Vertical Farming gibt es zwei Kategorien von erdfreien Anbautechniken. Hydroponische Systeme umspülen die Wurzeln der Pflanzen in einem sehr flachen Strom einer Wasserlösung, die Makronährstoffe enthält (Stickstoff, Phosphor, Kalium, etc.). Diese Technik heißt Nutrient Film Technique (NFT). Optional lassen sich als Bodenersatz reaktionsarme Medien wie Kiesel oder Sand einsetzen, die die Wurzeln anstelle von Erde unterstützen. Das nennt sich Ebbe-Flut-System.

Anders als die Hydrokultur braucht die Aeroponik kein flüssiges oder festes Medium, um Pflanzen darin anzubauen. Stattdessen wässert sie die Pflanzen über eine flüssige Lösung mit Nährstoffen (hier als HPA bezeichnet) oder benetzt sie mit einem Nebel (was Nebulisation heißt). Nebulisationsaeroponik gilt als nachhaltigste erdfreie Anbautechnik, weil sie 90 Prozent weniger Wasser benötigt als die effizientesten hydroponischen Systeme und keinen Austausch des Anbaumediums erfordert.

Jenseits der technischen und ökologischen Überlegungen beeinflusst das Bewässerungssystem das Wachstum des Gemüses sehr stark. Deshalb ist es ein Schlüsselparameter, den sowohl das Vertical Farming als auch die künstliche Intelligenz berücksichtigen müssen, die ich im kommenden Bereich vorstelle.

Tensorflow Lite

Die recht komplexe Tensorflow-Plattform bringt zahlreiche Komponenten mit: Das Tensorboard hilft beim Debuggen und Studieren der Trainingsschritte. TensorFlow.js erlaubt es, das Model und die Berechnungen im Webbrowser auszuführen. Tensorflow Lite eignet sich für Geräte mit wenig Speicher und geringen Rechenkapazitäten.

Tensorflow Lite bringt alle nötigen Bausteine mit, um ein Tensorflow-Modell auf Mobil-, Embedded- und IoT-Geräten zu erzeugen, zu konvertieren und zu optimieren, um es dann auf dem ressourcenarmen Edge-Device auszuführen. Allerdings lässt sich Tensorflow Lite, anders als Tensorflow, bislang nur in Ansätzen dazu verwenden, ein Machine-Learning-Modell zu entwickeln und zu trainieren.

Vereinfacht umfasst Tensorflow Lite zwei Komponenten: den Tensorflow Lite Converter und die Tensorflow Lite Runtime. Ersterer bietet alle notwendigen APIs an und bringt Optimierer mit, um den Speicher-Footprint des Tensorflow-Modells sowie die Berechnungskosten zu reduzieren und die Ausführungsgeschwindigkeit zu steigern. Der nächste Abschnitt geht detaillierter darauf ein.

Üblicherweise nimmt der Python-gestählte Datenwissenschaftler eine Analyse und Vorverarbeitung der Daten auf seinem Computer vor, indem er Pandas- [2] oder Numpy-Bibliotheken [3] verwendet. Danach greift er zu Tensorflow, um das Deep-Learning-Modell zu entwerfen und zu trainieren. Die Trainingsphase lässt sich optional auf eine GPU in der Cloud auslagern.

Schließlich setzt der Forscher auf seinem Computer den zur Tensorflow-Distribution gehörenden Tensorflow Lite Converter ein, um das trainierte Modell zu optimieren und in ein ».tflite«-Modell zu konvertieren, das sich für Edge-Geräte eignet. Dieses ».tflite«-Modell schiebt am Ende ein Software-Update auf das Edge-Gerät.

Zur Laufzeit verwendet das Edge-Gerät die Tensorflow-Lite-Laufzeitumgebung, um das Modell auszuführen und Vorhersagen auf Basis der Live-Daten aus der Vertical Farm zu treffen. Ein wichtiger Punkt hierbei: Auf dem Gerät läuft nicht die Tensorflow-Distribution, sondern nur eine alleinstehende Tensorflow-Lite-Runtime. Abhängig von der Plattform des Edge-Geräts, gibt es die Tensorflow Lite Runtime entweder als AAR-Paket von JCenter für Android, als Python-Wheel-Paket oder als in C geschriebene Shared Library für Embedded-Geräte.

Tensorflow Lite im Vertical Farming

Wir haben den in Abbildung 1 gezeigten Glasschrank für die vertikale Landwirtschaft in Innenräumen entworfen. Er verfügt über vier Regale, die zwölf auf einem Gitter verteilten Pflanzen Platz bieten. Das komplette Vertical-Farming-System umfasst vier Komponenten (Abbildung 2).

Abbildung 2: Im Schrank stecken vier Etagen mit Gemüse, die Daten landen zuerst auf einem lokalen Raspberry Pi.

Da wären erstens das Gehäuse sowie die Sensoren, Aktoren und Bewässerungssysteme. Die zweite Komponente ist eine Hauptplatine, in unserem Fall ein Raspberry Pi 3B+. Drittens benötigt das Setup einen Cloud-Server und viertens einen Forschungs- und Entwicklungsrechner (F&E).

Die erste Komponente, der Glasschrank, beherbergt die in Tabelle 1 aufgelisteten acht Sensoren sowie zwei Kameras pro Etage. Der Prototyp implementiert die vier verschiedenen Bewässerungssysteme, die ich weiter oben skizziert habe (eines auf jeder Schicht), um ihre Auswirkungen auf das Wachstum und die Qualität der Pflanzen zu untersuchen. Zusätzlich helfen Aktuatoren, die Temperatur, den CO₂-Gehalt und die Beleuchtung zu kontrollieren.

Der Raspberry Pi dient als Gehirn des Systems. Er sammelt die Daten der Sensoren und steuert die Bewässerungssysteme sowie Aktoren. Es berechnet auch die Pflanzenblattfläche mithilfe der Kameras und verschiedener Bildverarbeitungsalgorithmen, die auf Basis von OpenCV [4] laufen (Abbildung 3).

Abbildung 3: OpenCV behält die Salatköpfe im Auge und misst deren Größe. Tensorflow sagt dann das Erntedatum voraus.

Zugleich führt der RasPi die Tensorflow-Lite-Runtime aus, um den Deep-Learning-Algorithmus zur Vorhersage des Pflanzenwachstums in Echtzeit auszuführen. Alle Daten speichert er lokal zwischen, bevor er sie an eine Cloud-API sendet, sobald eine Internet-Verbindung zur Verfügung steht. Die Software, die den Raspberry Pi steuert, ist in Python geschrieben.

Die von uns eingesetzte Cloud bietet drei zentrale Features. Eine in Go entwickelte API sammelt die Daten vom Motherboard, also dem Raspberry Pi. Eine Postgres-Datenbank speichert die Daten, die der RasPi aus dem Glasschrank erhält, aber auch Informationen über die Details zu den Experimenten. Sie merkt sich auch Pflanzeneigenschaften – hauptsächlich für Agrarforschungszwecke –, zu denen die Sorte, das Anbaudatum und so weiter zählen. Drittens bietet die Cloud ein Webinterface zur Datenvisualisierung, das auf dem ELK-Stack (Elasticsearch, Logstash, Kibana [5]) beruht.

Salat im Training

Bei einem Regressionsproblem versucht der Entwickler, die Ausgabe eines kontinuierlichen Werts vorherzusagen, zum Beispiel der Temperatur oder des Gewichts. Im Gegensatz dazu zielt ein Klassifizierungsproblem darauf ab, eine bestimmte Klasse in einer Liste von Klassen zu identifizieren.

Um das Modell zu bauen, haben wir die mit Tensorflow 2.0 neu eingeführte »tf.keras«-API verwendet. Das Modell versucht, die Frischmasse (FM [6]) des Salats zu einem bestimmten Zeitpunkt nach der Pflanzung vorherzusagen. Dazu gilt es zunächst, das Forschungslabor aufzusetzen. Wir verwenden dazu Python 3.7, erzeugen eine virtuelle Umgebung und installieren dann Tensorflow (Listing 1, Zeile 1 bis 9). Über einen einfachen Befehl lässt sich anschließend prüfen, ob das Setup stimmig ist (Zeile 11).

$ python3 --version
$ pip3 --version
$ virtualenv --version
$ virtualenv --system-site-packages -p python3 ./venv
### Umgebung aktivieren
$ source ./venv/bin/activate
### Tensorflow-Distribution einrichten
$ pip install --upgrade pip
$ pip install --upgrade tensorflow=2.0 pandas numpy pathlib
### Tensorflow testen
$ python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000,**1000])))"

Neuronales Netzwerk bauen

Um den Entwurf des Modells einfach und leicht verständlich zu machen, betrachten wir im Folgenden zehn Merkmale aus Tabelle 2, wobei die Bewässerungssysteme in vier One-Hot-Spalten landen – es kommt stets nur eines der vier Systeme zum Einsatz.

Da wir mit Daten von echten Sensoren arbeiten, die eventuell ausfallen und kalibriert werden müssen, spielt das Vermeiden fehlerhafter Ergebnisse eine entscheidend Rolle. Es ist daher wichtig, starke Preprocessing-Techniken wie Abtastung, Filterung und Normalisierung zu implementieren, bevor man die Daten in das neuronale Netzwerk speist. Einen Beispieldatensatz zeigt das Listing 2.

Weight  DaP  CumCO2  CumLight  CumTemp  LeafArea  NFT  HPA  Ebb&Flood Nebu
135.0   10   4       1420.0    8623.0   156       0.0  1.0  0.0       0.0

Zunächst gilt es, den Datensatz in zwei Teile zu zerlegen, jeweils einen für das Training und einen für die Tests. Anschließend stellen die neun ersten Merkmale aus Tabelle 2 die Eingaben für das neuronale Netz dar. Das Gewicht, also den letzten Wert in der Tabelle, wollen wir vorhersagen. Es wird damit zur Ausgabe für das neuronale Netz.

Nun bauen wir das Modell auf (Listing 3). Dazu kommt ein einfaches sequenzielles Modell [7] mit zwei eng verbundenen verborgenen Schichten zum Einsatz. Dessen Ausgabeschicht liefert einen einzigen, kontinuierlichen Wert zurück: die Frischmasse des Salats.

import tensorflow as tf
[...]
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation=tf.nn.relu, input_shape=[len(train_dataset.keys())]),
    tf.keras.layers.Dense(64, activation=tf.nn.relu),
    tf.keras.layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mean_squared_error',
   optimizer=optimizer,
   metrics=['mean_absolute_error', 'mean_squared_error'])

Wir wählen nur zwei verborgene Schichten, da es nicht viele Trainingsdaten und lediglich neun Merkmale gibt. In diesem Fall eignet sich ein kleines Netzwerk mit wenigen verborgenen Schichten besser, um eine Überanpassung zu vermeiden. Für die Aktivierungsfunktion fällt die Wahl auf den Gleichrichter (englisch ReLU, Rectified Linear Unit). Als Verlustfunktion kommt der Mean Square Error (MSE) zum Einsatz, der bei Regressionsproblemen hilft. Klassifikationsprobleme benötigen andere Verlustfunktionen.

Abbildung 4 zeigt noch einmal das Modell. Die Zahl der Inputs für das neuronale Netzwerk beträgt 9, was mit der Zahl an Input-Merkmalen korrespondiert. Im nächsten Schritt lässt sich das Modell mit dem Trainingsdatensatz trainieren (Listing 4).

Abbildung 4: Als Input dienen dem eingesetzten »Sequential«-Modell die neun ersten Merkmale aus Tabelle 2. Das zehnte Merkmal ist der gesuchte Output.

model.fit(train_features, train_weights, epochs=100, validation_split=0.2, verbose=0))

Nach dem Training lässt sich das Modell speichern und exportieren (Listing 5). Wie sich zeigt, ist es insgesamt 86 077 Bytes groß und eignet sich damit noch nicht perfekt für Geräte mit begrenzten Ressourcen. Das lässt sich optimieren.

model_export_dir= "./models/lg_weight/"
tf.saved_model.save(model, model_export_dir)
root_directory = pathlib.Path(model_export_dir)
tf_model_size = sum(f.stat().st_size for f in root_directory.glob('**/*.pb') if f.is_file())
print("TF model is {} bytes".format(keras_model_size))

Schlankheitskur

Nun folgt der zentrale Teil des Tutorials. Zunächst geht es darum, das Modell ins Tensorflow-Lite-Format zu konvertieren, damit es von den Standardoptimierungen profitiert, und es dann zu speichern (Listing 6). Wie eine anschließende Überprüfung (Listing 7) ergibt, schrumpft das Modell dabei auf nur noch 20 912 Bytes Größe – vier Mal weniger als die ursprüngliche Tensorflow-Variante.

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
open('./models/model.tflite', "wb").write(tflite_model)

model_size = os.path.getsize('./models/model.tflite')
print("TFLite model is {} bytes".format(model_size))

Doch die Größe des Modells lässt sich noch weiter reduzieren, indem der Anwender die vom Tensorflow Lite Converter bereitgestellten Optimierer verwendet (Listing 8). Die einfachste Form der Quantisierung nach dem Training betrifft zum Beispiel nur die Gewichte und ändert die Präzision von Floating Point auf 8 Bit – eine sogenannte hybride Quantisierung. Das Modell schrumpft nun auf 8672 Bytes, was es zehn Mal kleiner macht als das Tensorflow-Originalmodell.

converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
tflite_quant_model = converter.convert()

Muster am Edge

Der vorhergehende Abschnitt führte in die Grundlagen ein, um ein Regressionsproblem in Form einer Vorhersage des Salatgewichts zu lösen. Dann zeigte er, wie sich ein mit Tensorflow entwickeltes Modell nach dem Training in das Tensorflow-Lite-Format konvertieren und dabei optimieren lässt. Nun ist es an der Zeit, das trainierte und optimierte Modell in der Datei »model.tflite« an das Gehirn zu übertragen, in diesem Fall an den Raspberry Pi der vertikalen Farm.

Hier sei daran erinnert, dass Nutzer auf IoT-Geräten nur die eigenständige und leichtgewichtige Tensorflow-Lite-Runtime installieren müssen. Wie auf dem F&E-Computer kommen dabei Python 3.7 und Pip zum Zug, um unter Raspbian “Buster” ein Wheel-Paket (».whl«) einzuspielen (Listing 9). Anschließend sind das Ausführen des Modells und das Generieren einer Vorhersage via Python-API recht einfach.

$ pip3 install https://dl.google.com/coral/python/tflite_runtime-2.1.0-cp37-cp37m-linux_armv7l.whl

Wie erwähnt, setzt das Setup auf reale Sensordaten. Das macht es entscheidend, starke Vorverarbeitungstechniken einzusetzen, also die Daten abzutasten, zu filtern und zu normalisieren, bevor man sie in das neuronale Netzwerk einspeist. Beim ersten Mal muss man dazu den Speicher für die Tensoren zuweisen (Listing 10).

import tflite_runtime.interpreter as tflite
interpreter = tflite.Interpreter(model_content=tflite_model_ffile)
interpreter.allocate_tensors()

Anschließend füttert der Entwickler die Eingabetensoren mit den neun Eingabemerkmalen, ruft den Interpreter auf und liest die Vorhersage ab. Im folgenden Codeschnipsel (Listing 11) enthält das Array »input_tensor« die Eingabemerkmale, also die Summe des Lichts, die Summe der Temperatur und weitere vorverarbeitete Daten. Die Variable »tensor_index« entspricht der Anzahl der Merkmale.

interpreter.set_tensor(tensor_index=9, value=input_tensor)
# run inference
interpreter.invoke()
# tensor_index is**0 since the output contains only a single value
weight_inferred = interpreter.get_tensor(tensor_index=0)

Resultate

Nun ist es an der Zeit, die Genauigkeit des Modells zu bewerten. Wie gut es verallgemeinert, lässt sich anhand eines Testdatensatzes überprüfen, der beim Training des Modells nicht zum Einsatz kam. Dieser Schritt verrät, wie gut die Vorhersagen des Modells in der realen Welt ausfallen.

Um die Genauigkeit auf einen Blick zu beurteilen, erzeugen wir zunächst die Grafik aus Abbildung 5. Die blauen Kreuzchen zeigen die abgeleiteten Gewichtswerte als Funktion der tatsächlichen Werte für den kompletten Testdatensatz. Der Fehler erscheint als Abstand zwischen den blauen Kreuzchen und der orangefarbenen Linie.

Abbildung 5: Der Fehler im Modell lässt sich über einen Testdatensatz herausfinden.

Eine beim Bewerten eines Regressionsmodells häufig verwendete Metrik ist der mittlere absolute Fehler, englisch Mean Absolute Percentage Error (MAPE [8]). Er verrät, wie sehr sich die vorhergesagten Werte von den beobachteten unterscheiden. Für unseren Testdatensatz beträgt der MAPE 9,44 Prozent – für den Betreiber einer Vertical Farm definitiv präzise genug.

Execution Time

Um die Lösung zu evaluieren, installieren wir schließlich die vollständige Tensorflow-Distribution auf einem Test-RasPi und vergleichen die Mustererkennung zwischen dem ursprünglichen Tensorflow-Modell auf der einen und dem optimierten ».tflite«-Modell von Tensorflow Lite auf der anderen Seite.

Es zeigt sich, dass Tensorflow Lite drei bis vier Mal schneller seine Schlüsse zieht als Tensorflow und die Prozessdauer im Bereich von wenigen Millisekunden liegt.

Fazit

Tensorflow Lite ermöglicht es dem Betreiber der vertikalen Farm, das Erntedatum des Salats recht genau vorherzusagen. Das erfordert weder einen leistungsstarken Server noch eine ständige Verbindung in die Cloud.

Indem wir die Rechenkosten und die Größe des neuronalen Netzwerkmodells reduzieren, läuft das Konstrukt auch am Edge auf einem Raspberry Pi, der Tensorflow Lite verwendet. Da die Aufgabe nur einen kleinen Fußabdruck im System erzeugt, kann der RasPi parallel andere kritische Tasks erledigen, die die Farm in Betrieb halten. Darüber hinaus läuft Tensorflow Lite auch auf so kompakten IoT-Geräten wie einem ARM-Cortex-M-Mikrocontroller.

Tensorflow Lite unterliegt jedoch einigen Einschränkungen. Es unterstützt nur eine Teilmenge von Operatoren, was das Design des Modells limitiert. Beispielsweise unterstützt es RNNs (Recurrent Neural Networks) nicht vollständig. Allerdings scheint ein Google-Team gerade daran zu arbeiten, diese Lücke für alle Modelle zu schließen, die Tensorflow derzeit anbietet.

Ein weiterer Schwachpunkt ist der fehlende Support für das Reinforcement Learning, das mehr Rechenkapazitäten erfordert, da es am Edge eine inkrementelle Trainingsaufgabe absolvieren muss. Diese Herausforderung ließe sich jedoch mit einem Edge-TPU-Gerät meistern oder auch mit Komponenten wie dem Google-Coral-Board [9] oder dem Coral-USB-Stick, die sich an einen Raspberry Pi stecken lassen. (kki)