.tflite — a TFLite modellformátum lényege, szerkezete és alkalmazása

A .tflite formátum lényege

A .tflite egy gépi tanulási modell szerializált reprezentációja, amely korlátozott memóriájú és számítási teljesítményű eszközökön történő inferenciára optimalizált. Ellentétben a SavedModel formátummal, amely a gráfot protobuf-ban tárolja és jelentős erőforrásokat igényel a betöltéshez, a .tflite a FlatBuffers-t használja — egy olyan szerializációs könyvtárat, amely másolás nélkül biztosít hozzáférést az adatokhoz.

A .tflite formátum a mobil platformok sajátosságainak figyelembevételével készült: minimális memóriafogyasztás betöltéskor, gyors indítás, kvantált súlyok támogatása. A .tflite fájl nem támogatja a tanítást — csak inferenciát. Ez alapvető különbség a teljes TensorFlow formátumokhoz képest, ami lehetővé teszi a futtatási környezet méretének jelentős csökkentését.

A Google Research, 2024 szerint a .tflite formátumú modellek INT8 kvantálással 60%-kal gyorsabban töltődnek be, mint a hasonló FP32 formátumú modellek, és 40%-kal kevesebb RAM-ot fogyasztanak inferencia közben.

A .tflite fájl belső szerkezete

A .tflite fájl több szekcióból áll, amelyek a FlatBuffers séma szerint vannak megszervezve. A fő szekció — a Model, amely tartalmazza a számítási gráfot (SubGraph), az operátorok listáját (OperatorCodes) és a súlyokkal rendelkező puffereket. Minden SubGraph tartalmaz tenzorokat, operátorokat, bemeneti és kimeneti indexeket.

Az OperatorCodes szekció tartalmazza a modellben használt összes operátor azonosítóját — Conv2D, DepthwiseConv2D, FullyConnected, Softmax és mások. Minden operátornak kódja van a BuiltinOperator előre meghatározott listájából. Ha a modell olyan műveleteket tartalmaz, amelyek nincsenek a listán, akkor ezek Customként vannak jelölve, és delegáláson vagy egyéni operátoron keresztül történő implementációt igényelnek.

A Buffers szekció a modellsúlyok bináris adatait tartalmazza. A kvantálási módtól függően a súlyok tárolhatók FP32, FP16, INT8 formátumban vagy kvantált formátumban skálázási paraméterekkel. A pufferek közvetlenül a memóriába vannak vetítve az mmap mechanizmuson keresztül, ami kiküszöböli a további másolást.

A .tflite fájl fő szekciói

Kvantálás és formátumoptimalizálás

A .tflite három kvantálási módot támogat. Teljes egész számú INT8 kvantálás — a súlyok és aktivációk 8 bites egész számokként vannak ábrázolva. A konverzióhoz reprezentatív adatkészlet szükséges az aktivációs tartományok kalibrálásához. A modell mérete 4-szeresére csökken.

FP16 kvantálás — a súlyok 16 bites lebegőpontos számokká alakulnak. Ez a mód nem igényel kalibrálást és minimális pontosságvesztéssel jár. Az aktivációk FP32-ben maradnak. A modell mérete 2-szeresére csökken. GPU és NPU FP16 támogatással rendelkező eszközökhöz ajánlott.

Dinamikus kvantálás — a súlyok INT8-ra vannak konvertálva, de az aktivációk FP32-ben számítódnak. A modell mérete 4-szeresére csökken, de a pontosság magasabb marad, mint a teljes INT8-nál. A Google ML Performance Benchmarks szerint ez a mód optimális az NLP modellekhez és a pontosságra nagy érzékenységű modellekhez.

.tflite létrehozása TensorFlow modellből

A modell .tflite formátumba konvertálásához a TFLite Converter használatos — egy TensorFlow komponens, amely a Python API tf.lite.TFLiteConverter segítségével érhető el. A Converter három forrást támogat: SavedModel, Keras H5 és ConcreteFunction. A Keras modell konvertálásának minimális példája:

import tensorflow as tf

# Töltse be a betanított Keras modellt fájlból
model = tf.keras.models.load_model("my_model.h5")

# Konvertálja .tflite formátumba dinamikus kvantálással
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Írja a konvertált modellt egy .tflite fájlba
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Teljes INT8 kvantálással történő konverzióhoz kalibrációs adatkészlet szükséges. Adja meg a representative_dataset paramétert az aktivációs tartományok meghatározásához:

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

Eszközök a .tflite használatához

A Google eszközkészletet biztosít a .tflite modellek elemzéséhez és optimalizálásához. A TFLite Benchmark Tool méri az inferenciaidőt az eszközön és statisztikákat jelenít meg minden operátorról. A TFLite Model Inspector vizualizálja a számítási gráfot és megjeleníti a tenzorok méretét.

Netron — egy platformfüggetlen modellvizualizáló, amely a .tflite-ot támogatja az ONNX, Core ML és PyTorch mellett. A Netron megjeleníti a gráf szerkezetét, az egyes operátorok paramétereit és a tenzorok közötti kapcsolatokat. Hasznos a konverzió során fellépő hibakereséshez.

A TFLite Metadata API lehetővé teszi metaadatok hozzáadását a .tflite fájlhoz: modell leírása, bemeneti adatok formátuma, mértékegységek, információ a szerzőről. A metaadatokat a Task Library használja az előfeldolgozás és utófeldolgozás automatikus konfigurálásához.

Példa a .tflite betöltésére és végrehajtására

Példa a .tflite modell betöltésére iOS rendszeren Swift API-val. A TFLite Swift API egy Interpreter-t biztosít a modell bundle-ból történő betöltéséhez és az inferencia végrehajtásához. Adjon meg egy delegált a hardveres gyorsításhoz a Core ML Delegate segítségével:

import TensorFlowLite

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

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

// Készítse elő a bemeneti adatokat a modellhez
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Futtassa a modell inferenciát
try interpreter.invoke()

// Olvassa ki a kimeneti tenzor adatait
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}