Listing 5
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.
Listing 6
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
open('./models/model.tflite', "wb").write(tflite_model)
Listing 7
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.
Listing 8
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.
Listing 9
$ 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).
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.
Listing 11
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.
