.tflite — Wesen, Struktur und Anwendung des TFLite-Modellformats

Was ist das .tflite-Format

.tflite ist eine serialisierte Darstellung eines maschinellen Lernmodells, optimiert für Inferenz auf Geräten mit begrenztem Speicher und begrenzter Rechenleistung. Im Gegensatz zum SavedModel-Format, das einen Graphen in protobuf speichert und erhebliche Ressourcen zum Laden benötigt, verwendet .tflite FlatBuffers — eine Serialisierungsbibliothek mit kopierfreiem Datenzugriff.

Das .tflite-Format wurde unter Berücksichtigung der Besonderheiten mobiler Plattformen entwickelt: minimaler Speicherverbrauch beim Laden, schneller Start und Unterstützung quantisierter Gewichte. Eine .tflite-Datei unterstützt kein Training, sondern nur Inferenz. Dies ist ein grundlegender Unterschied zu den vollständigen TensorFlow-Formaten und ermöglicht eine erhebliche Reduzierung der Laufzeitgröße.

Laut Google Research, 2024 werden Modelle im .tflite-Format mit INT8-Quantisierung 60% schneller geladen als vergleichbare FP32-Modelle und verbrauchen während der Inferenz 40% weniger RAM.

Interne Struktur der .tflite-Datei

Eine .tflite-Datei besteht aus mehreren Abschnitten, die nach dem FlatBuffers-Schema organisiert sind. Der Hauptabschnitt ist Model, der den Berechnungsgraphen (SubGraph), eine Liste von Operatoren (OperatorCodes) und Gewichtspuffer enthält. Jeder SubGraph enthält Tensoren, Operatoren sowie Eingabe- und Ausgabeindizes.

Der Abschnitt OperatorCodes enthält die Kennungen aller im Modell verwendeten Operatoren — Conv2D, DepthwiseConv2D, FullyConnected, Softmax und andere. Jeder Operator hat einen Code aus der vordefinierten BuiltinOperator-Liste. Enthält das Modell Operationen, die nicht in der Liste enthalten sind, werden sie als Custom markiert und erfordern eine Implementierung über einen Delegaten oder einen benutzerdefinierten Operator.

Der Abschnitt Buffers enthält die binären Gewichtsdaten des Modells. Abhängig vom Quantisierungsmodus können Gewichte in FP32, FP16, INT8 oder in einem quantisierten Format mit Skalierungsparametern gespeichert werden. Die Puffer werden über mmap direkt in den Speicher abgebildet, wodurch zusätzliches Kopieren entfällt.

Hauptabschnitte der .tflite-Datei

Quantisierung und Formatoptimierung

.tflite unterstützt drei Quantisierungsmodi. Vollständige Ganzzahl-INT8-Quantisierung — Gewichte und Aktivierungen werden als 8-Bit-Ganzzahlen dargestellt. Für die Konvertierung wird ein repräsentativer Datensatz zur Kalibrierung der Aktivierungsbereiche benötigt. Die Modellgröße wird um das 4-fache reduziert.

FP16-Quantisierung — Gewichte werden in 16-Bit-Gleitkommazahlen umgewandelt. Dieser Modus erfordert keine Kalibrierung und verursacht einen minimalen Genauigkeitsverlust. Aktivierungen bleiben in FP32. Die Modellgröße wird um das 2-fache reduziert. Empfohlen für Geräte mit FP16-Unterstützung auf GPU und NPU.

Dynamische Quantisierung — Gewichte werden in INT8 konvertiert, aber Aktivierungen werden in FP32 berechnet. Die Modellgröße wird um das 4-fache reduziert, während die Genauigkeit höher bleibt als bei vollständigem INT8. Laut Google ML Performance Benchmarks ist dieser Modus optimal für NLP-Modelle und Modelle mit hoher Genauigkeitsempfindlichkeit.

Erstellen von .tflite aus einem TensorFlow-Modell

Zur Konvertierung eines Modells in .tflite wird der TFLite Converter verwendet — eine TensorFlow-Komponente, die über die Python-API tf.lite.TFLiteConverter verfügbar ist. Der Konverter unterstützt drei Quellen: SavedModel, Keras H5 und ConcreteFunction. Ein minimales Beispiel für die Konvertierung eines Keras-Modells:

import tensorflow as tf

# Trainiertes Keras-Modell aus Datei laden
model = tf.keras.models.load_model("my_model.h5")

# Mit dynamischer Quantisierung in .tflite konvertieren
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Konvertiertes Modell in eine .tflite-Datei schreiben
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Für die Konvertierung mit vollständiger INT8-Quantisierung wird ein Kalibrierungsdatensatz benötigt. Geben Sie einen representative_dataset an, um die Aktivierungsbereiche zu bestimmen:

converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [
    tf.lite.OpsSet.TFLITE_BUILTINS_INT8
]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
tflite_quant_model = converter.convert()

Werkzeuge für die Arbeit mit .tflite

Google stellt eine Reihe von Werkzeugen zur Analyse und Optimierung von .tflite-Modellen bereit. Das TFLite Benchmark Tool misst die Inferenzzeit auf dem Gerät und zeigt Statistiken für jeden Operator an. Der TFLite Model Inspector visualisiert den Berechnungsgraphen und zeigt Tensorgrößen an.

Netron ist ein plattformübergreifender Modellvisualisierer, der .tflite neben ONNX, Core ML und PyTorch unterstützt. Netron zeigt die Graphenstruktur, Parameter jedes Operators und Verbindungen zwischen Tensoren an. Nützlich zum Debuggen bei der Konvertierung.

Die TFLite Metadata API ermöglicht das Hinzufügen von Metadaten zur .tflite-Datei: Modellbeschreibung, Eingabedatenformat, Maßeinheiten, Autoreninformationen. Die Metadaten werden von der Task Library zur automatischen Konfiguration von Vor- und Nachbearbeitung verwendet.

Beispiel zum Laden und Ausführen von .tflite

Beispiel zum Laden eines .tflite-Modells auf iOS mit der Swift API. Die TFLite Swift API stellt einen Interpreter zum Laden des Modells aus dem Bundle und zur Ausführung der Inferenz bereit. Geben Sie einen Delegaten für die Hardwarebeschleunigung über den Core ML Delegate an:

import TensorFlowLite

guard let modelPath = Bundle.main.path(
    forResource: "model", ofType: "tflite"
) else { return }

let interpreter = try Interpreter.init(modelPath: modelPath)
try interpreter.allocateTensors()

// Eingabedaten für das Modell vorbereiten
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Modellinferenz ausführen
try interpreter.invoke()

// Ausgabetensordaten lesen
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}