Modellkonvertierung zu TensorFlow Lite

TensorFlow Lite (TFLite) wurde entwickelt, um ML-Modelle auf Edge-Geräten auszuführen, die normalerweise über begrenzte Rechenleistung und Speicher verfügen. Hier sind einige Gründe, warum die Verwendung von TFLite sinnvoll ist:

• Effizienz: TFLite ist auf Effizienz ausgelegt und bietet optimierte Berechnungen, um die Ausführung auf ressourcenbeschränkten Geräten zu beschleunigen.

• Plattformunabhängigkeit: TFLite unterstützt verschiedene Hardwareplattformen und Betriebssysteme, was die Bereitstellung auf verschiedenen Edge-Geräten erleichtert.

• Unterstützung für spezielle Hardware: TFLite ermöglicht die Nutzung spezialisierter Hardwarebeschleuniger, um die Inferenz noch schneller zu machen.

Schritte zur Modellkonvertierung

Die Konvertierung eines TensorFlow Modells in das TFLite-Format umfasst die folgenden Schritte:

1. Modellvorbereitung: Laden des Modells und die Konfiguration von Eingabe- und Ausgabe-Tensoren.

2. Modellkonvertierung und Quantisierung: Verwenden der TensorFlow-Bibliothek, um das Modell in das TFLite-Format zu konvertieren. Hier wird das TensorFlow-Modell in ein TensorFlow Lite-Modell konvertiert, wobei optional eine Quantisierung angewendet wird, um die Modellgröße zu reduzieren und die Inferenzgeschwindigkeit zu verbessern.

3. TFLite-Modell speichern: Das konvertierte TFLite-Modell wird in einer Datei gespeichert, die auf Edge-Geräten geladen und ausgeführt werden kann.

# Erstellen eines TFLiteConverter-Objekts aus einem TensorFlow-Modell
converter = lite.TFLiteConverter.from_keras_model(model)

# Prüfung, ob Quantisierung angewendet werden soll
if quantization:
		# Definierung der Optimierungen, während der Konvertierung
    converter.optimizations = [tf.lite.Optimize...]
    # Überprüfung, ob eine Quantisierung auf int8-Basis durchgeführt werden soll
    if quant_int8:
		    # Zuweisung eines repräsentativen Datensatzes, zur Kalibrierung des Modells
				# während der Quantisierung.
				converter.representative_dataset = representative_dataset
				# Festlegen der unterstützten Operationen auf TFLite-Ops
        converter.target_spec.supported_ops = [tf.lite.OpsSet...]
        # Festlegen des Eingabetyps für Inferenzen
        converter.inference_input_type = ...
        # Festlegen des Ausgabetyps für Inferenzen
        converter.inference_output_type = ...

# Konvertieren des TensorFlow-Modells in ein TensorFlow Lite-Modell
tflite_model = converter.convert()
# Speichern des konvertierten Modells als eine .tflite-Datei
open("tflite_model.tflite", "wb").write(tflite_model)

Modelkonvertierung zu C++-Modell

In einigen Fällen kann es erforderlich sein, das Modell in eine C++-Darstellung zu konvertieren, um es auf bestimmten Hardwareplattformen wie bspw. Mikrocontrollern auszuführen. Wie das Modell in ein C++-Modell konvertiert werden kann, wird im folgenden mit einem Beispiel in Python gezeigt:

Dieser Code konvertiert das TensorFlow Lite-Modell in ein C++-Array, um es in einer C++-Anwendung einzubetten und zu verwenden.

# Öffnen der TensorFlow Lite Modelldatei im Binärmodus
with open(model_name + '.tflite', 'rb') as f:
		# Lesen des Inhalts der Datei und Konvertierung in eine Hexadezimaldarstellung
    content = f.read().hex()
    # Umwandlung des Hex-Strings zurück in ein ByteArray,
    # um es leichter in einer C++-Datei zu formatieren.
    result = bytearray.fromhex(content)
    
    # Erstellen einer neuen C++-Quelldatei für das Modell, um die Daten einzubetten
    with open(model_name + "_data.cpp", "wb") as w:
        values_in_row = 0
        num_values = 0

				# Schreiben des Anfangs der C++-Datei, inklusive eines Includes
				# und der Deklaration des Datenarrays.
        w.write(bytearray('#include "' + model_name + '_data.h"\n'
                            "\n"
                            "const unsigned char " + model_name + "_tflite[]"
                            " DATA_ALIGN_ATTRIBUTE = {\n    ", 'utf-8'))
				# Iterieren über jedes Byte in den Modelldaten und
				# Formatierung jedes Bytes als Hexadezimalwert
        for value in result:
            num_values += 1
            values_in_row += 1
            value = "0x{:02x}".format(value)

						# Logik zur ordentlichen Formatierung der Werte im Array
            if values_in_row == 1:
                w.write(bytearray(value, 'utf-8'))
            elif values_in_row == 12:
                w.write(bytearray(", " + str(value) + ",\n    ", 'utf-8'))
                values_in_row = 0
            else:
                w.write(bytearray(', ' + str(value), 'utf-8'))

				# Abschluss der Arraydeklaration und der Datei
        w.write(bytearray("};\nconst int " + model_name + "_tflite_len = "
                            + str(num_values) + ";", 'utf-8'))

# Erstellen der dazugehörigen Header-Datei, die das extern deklarierte
# Array und dessen Länge definiert.
with open(model_name + "_data.h", "w") as f:
    f.write('#ifndef TENSORFLOW_LITE_MODEL_DATA_H_\n'
            '#define TENSORFLOW_LITE_MODEL_DATA_H_\n'
            '\n'
            'extern const unsigned char ' + model_name + '_tflite[];\n'
            'extern const int ' + model_name + '_tflite_len;\n'
            '\n'
            '#endif')

Mehr erfahren: PyTorch/Loading a TorchScript Model in C++, Medium/Exporting trained TensorFlow models to C++ the RIGHT way!