.tflite — essens, struktur och tillämpning av TFLite-modellformatet

Essens av .tflite-formatet

.tflite är en serialiserad representation av en maskininlärningsmodell, optimerad för inferens på enheter med begränsat minne och beräkningskraft. Till skillnad från SavedModel-formatet, som lagrar grafen i protobuf och kräver betydande resurser för att laddas, använder .tflite FlatBuffers — ett serialiseringsbibliotek med åtkomst till data utan kopiering.

.tflite-formatet är utformat med hänsyn till mobilplattformars egenskaper: minimal minnesförbrukning vid inläsning, snabb start, stöd för kvantiserade vikter. .tflite-filen stöder inte träning — endast inferens. Detta är en grundläggande skillnad från fullständiga TensorFlow-format, vilket gör det möjligt att avsevärt minska storleken på körningsmiljön.

Enligt Google Research, 2024 laddas modeller i .tflite-format med INT8-kvantisering 60% snabbare än jämförbara modeller i FP32-format och förbrukar 40% mindre RAM under inferens.

Intern struktur av .tflite-filen

En .tflite-fil består av flera sektioner, organiserade enligt FlatBuffers-schemat. Huvudsektionen — Model, som innehåller beräkningsgrafen (SubGraph), en lista över operatorer (OperatorCodes) och buffertar med vikter. Varje SubGraph innehåller tensorer, operatorer, in- och utdataindex.

Sektionen OperatorCodes innehåller identifierare för alla operatorer som används i modellen — Conv2D, DepthwiseConv2D, FullyConnected, Softmax och andra. Varje operator har en kod från den fördefinierade listan BuiltinOperator. Om modellen innehåller operationer som inte finns i listan markeras de som Custom och kräver implementering via en delegat eller anpassad operator.

Sektionen Buffers innehåller binära data för modellvikterna. Beroende på kvantiseringsläge kan vikter lagras i FP32, FP16, INT8 eller i kvantiserat format med skalningsparametrar. Buffertar mappas direkt till minnet via mmap-mekanismen, vilket eliminerar extra kopiering.

Huvudsektioner i .tflite-filen

Kvantisering och optimering av formatet

.tflite stöder tre kvantiseringslägen. Full heltals-INT8-kvantisering — vikter och aktiveringar representeras som 8-bitars heltal. För konvertering krävs en representativ datamängd för kalibrering av aktiveringsintervall. Modellstorleken minskar 4 gånger.

FP16-kvantisering — vikter konverteras till 16-bitars flyttal. Detta läge kräver ingen kalibrering och ger minimal noggrannhetsförlust. Aktiveringar förblir i FP32. Modellstorleken minskar 2 gånger. Rekommenderas för enheter med FP16-stöd på GPU och NPU.

Dynamisk kvantisering — vikter konverteras till INT8, men aktiveringar beräknas i FP32. Modellstorleken minskar 4 gånger, men noggrannheten förblir högre än vid full INT8. Enligt Google ML Performance Benchmarks är detta läge optimalt för NLP-modeller och modeller med hög känslighet för noggrannhet.

Skapa .tflite från en TensorFlow-modell

För konvertering av modellen till .tflite används TFLite Converter — en TensorFlow-komponent som är tillgänglig via Python API tf.lite.TFLiteConverter. Converter stöder tre källor: SavedModel, Keras H5 och ConcreteFunction. Ett minimalt exempel på konvertering av en Keras-modell:

import tensorflow as tf

# Ladda den tränade Keras-modellen från fil
model = tf.keras.models.load_model("my_model.h5")

# Konvertera till .tflite med dynamisk kvantisering
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Skriv den konverterade modellen till en .tflite-fil
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

För konvertering med full INT8-kvantisering krävs en kalibreringsdatamängd. Ange representative_dataset för att bestämma aktiveringsintervall:

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

Verktyg för att arbeta med .tflite

Google tillhandahåller en uppsättning verktyg för analys och optimering av .tflite-modeller. TFLite Benchmark Tool mäter inferenstiden på enheten och visar statistik för varje operator. TFLite Model Inspector visualiserar beräkningsgrafen och visar tensorstorlekar.

Netron — en plattformsoberoende modellvisualiserare som stöder .tflite tillsammans med ONNX, Core ML och PyTorch. Netron visar grafstrukturen, parametrar för varje operator och kopplingar mellan tensorer. Användbart för felsökning vid konvertering.

TFLite Metadata API gör det möjligt att lägga till metadata i .tflite-filen: modellbeskrivning, format för indata, mätenheter, information om författaren. Metadata används av Task Library för automatisk konfiguration av förbehandling och efterbehandling.

Exempel på inläsning och körning av .tflite

Exempel på inläsning av .tflite-modell på iOS med Swift API. TFLite Swift API tillhandahåller en Interpreter för inläsning av modellen från bundle och körning av inferens. Ange en delegat för hårdvaruacceleration 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()

// Förbered indata för modellen
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Kör modellinferens
try interpreter.invoke()

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