TF Lite Interpreter — klíčové pojmy, rozhraní a spouštění modelů

Klíčové pojmy TF Lite Interpreter

TF Lite Interpreter je minimalistické běhové prostředí, které spouští model strojového učení na zařízení bez serverové infrastruktury. Interpreter nepodporuje trénování — pouze inferenci. Díky tomu je lehký: binární velikost základního interpretru na Androidu je přibližně 300 KB.

Interpreter pracuje s modelem ve formátu .tflite, založeném na FlatBuffers. Při vytvoření Interpreter načítá model do paměti přes mmap, což zajišťuje přímý přístup k datům bez kopírování. Poté Interpreter alokuje tensory na základě popisu z modelu a je připraven k provedení.

Každá instance Interpreteru není vláknově bezpečná. Pro paralelní provádění jednoho modelu ve více vláknech vytvořte samostatné instance Interpreteru s kopiemi modelu. Pro sekvenční volání v jednom vlákně lze instanci Interpreteru opakovaně používat.

API interpretru na Android a iOS

Na Androidu je Interpreter k dispozici prostřednictvím Java API v balíčku org.tensorflow.lite.Interpreter. Hlavní metoda — run(Object input, Object output) — přijímá vícerozměrná pole nebo ByteBuffer. Pro jemnější řízení použijte metody runForMultipleInputsOutputs() a resizeInput().

Na iOS je Interpreter k dispozici prostřednictvím Swift API v modulu TensorFlowLite. Základní rozhraní je analogické Androidu: inicializace přes Interpreter.init(modelPath:), alokace tensorů přes allocateTensors(), provedení přes invoke(). Swift API podporuje Data a MLMultiTensor jako typy vstupních dat.

Srovnání API podle platforem

Konfigurace delegátů pro hardwarové zrychlení

Delegáty jsou komponenty, které přenášejí provádění operací na specializovaný hardware. GPU Delegate používá OpenGL ES (Android) a Metal (iOS) pro urychlení grafických operací. NNAPI Delegate přenáší provádění na NPU, DSP nebo GPU přes Android Neural Networks API.

Core ML Delegate je k dispozici na iOS a překládá operace TFLite do formátu Core ML. Podle Apple ML Benchmarking použití Core ML Delegate na iPhone 15 Pro urychluje inferenci až 4x ve srovnání s CPU. Delegát podporuje operace FP32 a FP16.

XNNPACK Delegate je univerzální řešení pro ARM CPU, optimalizované pro mobilní procesory. Nevyžaduje speciální hardware a podporuje INT8, FP16 a FP32. Doporučuje se jako výchozí delegát, který se aktivuje na všech zařízeních.

Správa paměti a tensorů

Interpreter spravuje tensory prostřednictvím paměťového poolu, který je alokován při volání allocateTensors(). Velikost poolu je určena na základě popisu modelu v souboru .tflite. Po alokaci interpretr nepřiděluje další paměť během inference.

Pro modely s dynamickými velikostmi vstupů použijte resizeInput(). Tato metoda přerozděluje paměť pro vstupní tensory s ohledem na novou velikost. Po změně velikosti vstupního tensoru může být vyžadována nová alokace přes allocateTensors().

Při práci s více modely je důležité uvolňovat zdroje pomocí close(). Neuvolněné Interpretery mohou vést k únikům paměti, zejména na zařízeních s omezenou RAM. Pro iOS použijte automatické počítání referencí ARC, pro Android — try-with-resources nebo explicitní volání close().

Zpracování chyb a ladění

Nejčastější chyby při práci s Interpreterem — nesoulad rozměrů tensorů. Pokud vstupní data neodpovídají očekávanému tvaru, Interpreter vyvolá IllegalArgumentException na Androidu nebo runtime chybu na iOS. Zkontrolujte rozměry pomocí inputTensorAt() a outputTensorAt().

Druhý běžný problém — nepodporované operátory při použití delegáta. Pokud delegát nepodporuje operátor, Interpreter automaticky přejde na CPU pro tento operátor. Pro detekci takových situací zapněte protokolování přes setCancelled() nebo zkontrolujte protokoly TFLite.

TFLite poskytuje Benchmark Tool pro profilování: měření času každého operátoru, spotřeba paměti, porovnání delegátů. Benchmark Tool je k dispozici jako součást TFLite Support Library a lze jej spustit přímo na zařízení.

Příklady inference přes Interpreter

Příklad provádění modelu na Androidu s Java API pomocí GPU Delegate. Interpreter je vytvořen s možnostmi, které zahrnují GPU delegáta. Po provedení inference je výsledek přečten z výstupního tensoru:

import org.tensorflow.lite.Interpreter;
import org.tensorflow.lite.gpu.GpuDelegate;
import java.nio.MappedByteBuffer;

MappedByteBuffer model = loadModelFile(context);
GpuDelegate gpu = new GpuDelegate();
Interpreter.Options opts = new Interpreter.Options().addDelegate(gpu);
Interpreter interpreter = new Interpreter.create(model, opts);

float[][] input = preprocessImage(bitmap);
float[][] output = new float[1][1000];
interpreter.run(input, output);

int bestClass = argmax(output[0]);
Log.d("TFLite", "Nejvyšší třída: " + bestClass);

gpu.close();
interpreter.close();

Příklad provádění na Pythonu pro testování před nasazením. Python API TFLite umožňuje načíst .tflite, provést inferenci a zobrazit výsledek. Používá se pro ladění a kontrolu přesnosti modelu:

import tensorflow as tf
import numpy as np

# Načti model TFLite ze souboru
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Získej podrobnosti o vstupních a výstupních tensorech
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Připrav náhodná vstupní data pro testování
input_data = np.random.randn(
    *input_details[0]["shape"]
).astype(np.float32)

interpreter.set_tensor(input_details[0]["index"], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]["index"])
print("Tvar výstupu:", output_data.shape)