.tflite — essentie, structuur en toepassing van het TFLite-modelformaat

Essentie van het .tflite-formaat

.tflite is een geserialiseerde weergave van een machine learning-model, geoptimaliseerd voor inferentie op apparaten met beperkt geheugen en rekenkracht. In tegenstelling tot het SavedModel-formaat, dat de grafiek in protobuf opslaat en aanzienlijke bronnen nodig heeft om te laden, gebruikt .tflite FlatBuffers — een serialisatiebibliotheek met toegang tot gegevens zonder kopiëren.

Het .tflite-formaat is ontworpen met kenmerken van mobiele platforms in gedachten: minimaal geheugengebruik bij laden, snelle start, ondersteuning voor gekwantiseerde gewichten. Het .tflite-bestand ondersteunt geen training — alleen inferentie. Dit is een fundamenteel verschil met volledige TensorFlow-formaten, waardoor de grootte van de runtime aanzienlijk kan worden verkleind.

Volgens Google Research, 2024 laden modellen in .tflite-formaat met INT8-kwantificatie 60% sneller dan vergelijkbare modellen in FP32-formaat en verbruiken ze 40% minder RAM tijdens inferentie.

Interne structuur van het .tflite-bestand

Een .tflite-bestand bestaat uit verschillende secties, georganiseerd volgens het FlatBuffers-schema. De hoofdsectie — Model, die de berekengrafiek (SubGraph), lijst van operatoren (OperatorCodes) en buffers met gewichten bevat. Elke SubGraph bevat tensoren, operatoren, invoer- en uitvoerindices.

De sectie OperatorCodes bevat identificaties van alle operatoren die in het model worden gebruikt — Conv2D, DepthwiseConv2D, FullyConnected, Softmax en andere. Elke operator heeft een code uit de vooraf gedefinieerde lijst BuiltinOperator. Als het model operaties bevat die niet in de lijst voorkomen, worden ze gemarkeerd als Custom en vereisen ze implementatie via een delegatie of aangepaste operator.

De sectie Buffers bevat de binaire gegevens van modelgewichten. Afhankelijk van de kwantificatiemodus kunnen gewichten worden opgeslagen in FP32, FP16, INT8 of in gekwantiseerd formaat met schaalparameters. Buffers worden direct in het geheugen toegewezen via het mmap-mechanisme, wat extra kopiëren elimineert.

Belangrijkste secties van het .tflite-bestand

Kwantificatie en optimalisatie van het formaat

.tflite ondersteunt drie kwantificatiemodi. Volledige integer INT8-kwantificatie — gewichten en activeringen worden weergegeven als 8-bits gehele getallen. Voor conversie is een representatieve dataset nodig voor kalibratie van activeringsbereiken. De modelgrootte wordt 4 keer kleiner.

FP16-kwantificatie — gewichten worden omgezet naar 16-bits drijvende-kommagetallen. Deze modus vereist geen kalibratie en geeft minimaal precisieverlies. Activeringen blijven in FP32. De modelgrootte wordt 2 keer kleiner. Aanbevolen voor apparaten met FP16-ondersteuning op GPU en NPU.

Dynamische kwantificatie — gewichten worden geconverteerd naar INT8, maar activeringen worden berekend in FP32. De modelgrootte wordt 4 keer kleiner, maar de precisie blijft hoger dan bij volledige INT8. Volgens Google ML Performance Benchmarks is deze modus optimaal voor NLP-modellen en modellen met hoge gevoeligheid voor precisie.

.tflite maken van een TensorFlow-model

Voor het converteren van een model naar .tflite wordt TFLite Converter gebruikt — een TensorFlow-component die toegankelijk is via Python API tf.lite.TFLiteConverter. Converter ondersteunt drie bronnen: SavedModel, Keras H5 en ConcreteFunction. Een minimaal voorbeeld van het converteren van een Keras-model:

import tensorflow as tf

# Laad het getrainde Keras-model uit bestand
model = tf.keras.models.load_model("my_model.h5")

# Converteer naar .tflite met dynamische kwantificatie
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Schrijf het geconverteerde model naar een .tflite-bestand
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Voor conversie met volledige INT8-kwantificatie is een kalibratiedataset vereist. Specificeer representative_dataset voor het bepalen van activeringsbereiken:

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()

Tools voor het werken met .tflite

Google biedt een set tools voor analyse en optimalisatie van .tflite-modellen. TFLite Benchmark Tool meet de inferentietijd op het apparaat en toont statistieken per operator. TFLite Model Inspector visualiseert de berekengrafiek en toont tensorafmetingen.

Netron — een platformonafhankelijke modelvisualisator die .tflite ondersteunt naast ONNX, Core ML en PyTorch. Netron toont de grafiekstructuur, parameters van elke operator en verbindingen tussen tensoren. Handig voor debuggen tijdens conversie.

TFLite Metadata API maakt het mogelijk metadata aan het .tflite-bestand toe te voegen: modelbeschrijving, formaat van invoergegevens, meeteenheden, informatie over de auteur. Metadata worden gebruikt door Task Library voor automatische configuratie van preprocessing en postprocessing.

Voorbeeld van laden en uitvoeren van .tflite

Voorbeeld van het laden van een .tflite-model op iOS met Swift API. TFLite Swift API biedt een Interpreter voor het laden van het model uit de bundle en het uitvoeren van inferentie. Specificeer een delegatie voor hardwareversnelling via Core ML Delegate:

import TensorFlowLite

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

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

// Bereid invoergegevens voor het model voor
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Voer modelinferentie uit
try interpreter.invoke()

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