.tflite — istota, struktura i zastosowanie formatu modelu TFLite

Istota formatu .tflite

.tflite to serializowana reprezentacja modelu uczenia maszynowego, zoptymalizowana do inferencji na urządzeniach z ograniczoną pamięcią i mocą obliczeniową. W przeciwieństwie do formatu SavedModel, który przechowuje graf w protobuf i wymaga znacznych zasobów do załadowania, .tflite używa FlatBuffers — biblioteki serializacji z dostępem do danych bez kopiowania.

Format .tflite został zaprojektowany z uwzględnieniem specyfiki platform mobilnych: minimalne zużycie pamięci podczas ładowania, szybki start, obsługa skwantowanych wag. Plik .tflite nie obsługuje uczenia — tylko inferencję. To zasadnicza różnica w porównaniu z formatami pełnego TensorFlow, co pozwala znacznie zmniejszyć rozmiar środowiska uruchomieniowego.

Według Google Research, 2024, modele w formacie .tflite z kwantyzacją INT8 ładują się o 60% szybciej niż analogiczne modele w formacie FP32 i zużywają o 40% mniej pamięci RAM podczas inferencji.

Wewnętrzna struktura pliku .tflite

Plik .tflite składa się z kilku sekcji, zorganizowanych według schematu FlatBuffers. Główna sekcja — Model, która zawiera graf obliczeń (SubGraph), listę operatorów (OperatorCodes) i bufory z wagami. Każdy SubGraph zawiera tensory, operatory, indeksy wejściowe i wyjściowe.

Sekcja OperatorCodes zawiera identyfikatory wszystkich operatorów używanych w modelu — Conv2D, DepthwiseConv2D, FullyConnected, Softmax i inne. Każdy operator ma kod z predefiniowanej listy BuiltinOperator. Jeśli model zawiera operacje, których nie ma na liście, są one oznaczane jako Custom i wymagają implementacji przez delegata lub operator niestandardowy.

Sekcja Buffers zawiera binarne dane wag modelu. W zależności od trybu kwantyzacji wagi mogą być przechowywane w FP32, FP16, INT8 lub w formacie skwantowanym z parametrami skalowania. Bufory są mapowane do pamięci bezpośrednio przez mechanizm mmap, co eliminuje dodatkowe kopiowanie.

Główne sekcje pliku .tflite

Kwantyzacja i optymalizacja formatu

.tflite obsługuje trzy tryby kwantyzacji. Pełna całkowitoliczbowa kwantyzacja INT8 — wagi i aktywacje są reprezentowane jako 8-bitowe liczby całkowite. Do konwersji wymagany jest reprezentatywny zestaw danych do kalibracji zakresów aktywacji. Rozmiar modelu zmniejsza się 4-krotnie.

Kwantyzacja FP16 — wagi są przekształcane na 16-bitowe liczby zmiennoprzecinkowe. Ten tryb nie wymaga kalibracji i daje minimalną utratę dokładności. Aktywacje pozostają w FP32. Rozmiar modelu zmniejsza się 2-krotnie. Zalecany dla urządzeń z obsługą FP16 na GPU i NPU.

Kwantyzacja dynamiczna — wagi są konwertowane do INT8, ale aktywacje są obliczane w FP32. Rozmiar modelu zmniejsza się 4-krotnie, ale dokładność pozostaje wyższa niż w przypadku pełnego INT8. Według Google ML Performance Benchmarks, ten tryb jest optymalny dla modeli NLP i modeli o wysokiej wrażliwości na dokładność.

Tworzenie .tflite z modelu TensorFlow

Do konwersji modelu do .tflite używa się TFLite Converter — komponentu TensorFlow dostępnego przez Python API tf.lite.TFLiteConverter. Converter obsługuje trzy źródła: SavedModel, Keras H5 i ConcreteFunction. Minimalny przykład konwersji modelu Keras:

import tensorflow as tf

# Wczytaj wytrenowany model Keras z pliku
model = tf.keras.models.load_model("my_model.h5")

# Konwertuj do .tflite z dynamiczną kwantyzacją
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# Zapisz przekonwertowany model do pliku .tflite
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

Do konwersji z pełną kwantyzacją INT8 wymagany jest kalibracyjny zestaw danych. Podaj representative_dataset do określenia zakresów aktywacji:

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

Narzędzia do pracy z .tflite

Google udostępnia zestaw narzędzi do analizy i optymalizacji modeli .tflite. TFLite Benchmark Tool mierzy czas inferencji na urządzeniu i wyświetla statystyki dla każdego operatora. TFLite Model Inspector wizualizuje graf obliczeń i pokazuje rozmiary tensorów.

Netron — wieloplatformowy wizualizator modeli, obsługujący .tflite obok ONNX, Core ML i PyTorch. Netron wyświetla strukturę grafu, parametry każdego operatora i połączenia między tensorami. Przydatny do debugowania podczas konwersji.

TFLite Metadata API pozwala dodawać do pliku .tflite metadane: opis modelu, format danych wejściowych, jednostki miar, informacje o autorze. Metadane są używane przez Task Library do automatycznej konfiguracji preprocessingu i postprocessingu.

Przykład ładowania i wykonywania .tflite

Przykład ładowania modelu .tflite na iOS z Swift API. TFLite Swift API udostępnia Interpreter do ładowania modelu z bundle'a i wykonywania inferencji. Określ delegata do przyspieszenia sprzętowego przez 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()

// Przygotuj dane wejściowe dla modelu
let inputData = Data.init(count: 1 * 224 * 224 * 3)
try interpreter.copy(inputData, toInputAt: 0)

// Wykonaj inferencję modelu
try interpreter.invoke()

// Odczytaj dane tensora wyjściowego
let outputTensor = try interpreter.output(at: 0)
let results = outputTensor.data.withUnsafeBytes {
    Array($0.bindMemory(to: Float32.self))
}