TF Lite Interpreter — nyckelbegrepp, gränssnitt och körning av modeller

Nyckelbegrepp för TF Lite Interpreter

TF Lite Interpreter är en minimalistisk körtid som kör en maskininlärningsmodell på enheten utan serverinfrastruktur. Interpretatorn stöder inte träning — endast inferens. Detta gör den lätt: den binära storleken för basinterpretatorn på Android är cirka 300 KB.

Interpretatorn arbetar med modellen i .tflite-format, baserat på FlatBuffers. Vid skapande laddar Interpretatorn modellen i minnet via mmap, vilket ger direkt åtkomst till data utan kopiering. Därefter allokerar Interpretatorn tensorer baserat på modellbeskrivningen och är redo för körning.

Varje instans av Interpretatorn är inte trådsäker. För parallell körning av en modell i flera trådar, skapa separata instanser av Interpretatorn med kopior av modellen. För sekventiella anrop i en tråd kan instansen av Interpretatorn återanvändas.

Interpretator-API på Android och iOS

På Android är Interpretatorn tillgänglig via Java API i paketet org.tensorflow.lite.Interpreter. Huvudmetoden — run(Object input, Object output) — accepterar flerdimensionella arrayer eller ByteBuffer. För mer detaljerad kontroll, använd metoderna runForMultipleInputsOutputs() och resizeInput().

På iOS är Interpretatorn tillgänglig via Swift API i modulen TensorFlowLite. Grundgränssnittet liknar Android: initiering via Interpreter.init(modelPath:), allokering av tensorer via allocateTensors(), körning via invoke(). Swift API stöder Data och MLMultiTensor som indatatyper.

API-jämförelse per plattform

Konfigurering av delegater för hårdvaruacceleration

Delegater är komponenter som överför utförandet av operationer till specialiserad hårdvara. GPU Delegate använder OpenGL ES (Android) och Metal (iOS) för att accelerera grafiska operationer. NNAPI Delegate överför utförandet till NPU, DSP eller GPU via Android Neural Networks API.

Core ML Delegate är tillgänglig på iOS och översätter TFLite-operationer till Core ML-format. Enligt Apple ML Benchmarking accelererar användning av Core ML Delegate på iPhone 15 Pro inferens upp till 4x jämfört med CPU. Delegaten stöder FP32- och FP16-operationer.

XNNPACK Delegate är en universallösning för ARM CPU, optimerad för mobila processorer. Kräver ingen speciell hårdvara och stöder INT8, FP16 och FP32. Rekommenderas som basdelegat som aktiveras på alla enheter.

Hantering av minne och tensorer

Interpretatorn hanterar tensorer via en minnespool som allokeras vid anrop av allocateTensors(). Poolens storlek bestäms baserat på modellbeskrivningen i .tflite-filen. Efter allokering allokerar interpretatorn inte ytterligare minne under inferens.

För modeller med dynamiska indatastorlekar använd resizeInput(). Denna metod omfördelar minnet för indatatensorer med hänsyn till den nya storleken. Efter ändring av indatatensorns storlek kan omallokering via allocateTensors() krävas.

Vid arbete med flera modeller är det viktigt att frigöra resurser via close(). Ofrigjorda Interpretatorer kan leda till minnesläckor, särskilt på enheter med begränsat RAM. För iOS, använd automatisk referensräkning ARC, för Android — try-with-resources eller explicit anrop av close().

Felhantering och felsökning

De vanligaste felen vid arbete med Interpretatorn — matchningsproblem med tensordimensioner. Om indata inte matchar den förväntade formen kastar Interpretatorn IllegalArgumentException på Android eller runtime-fel på iOS. Kontrollera dimensioner via inputTensorAt() och outputTensorAt().

Det andra vanliga problemet — ej stödda operatorer vid användning av delegat. Om delegaten inte stöder en operator återgår Interpretatorn automatiskt till CPU för den operatorn. För att upptäcka sådana situationer, aktivera loggning via setCancelled() eller kontrollera TFLite-loggar.

TFLite tillhandahåller Benchmark Tool för profilering: mätning av tid för varje operator, minnesförbrukning, jämförelse av delegater. Benchmark Tool är tillgängligt som en del av TFLite Support Library och kan köras direkt på enheten.

Exempel på inferens via Interpretatorn

Exempel på modellkörning på Android med Java API med GPU Delegate. Interpretatorn skapas med alternativ som inkluderar GPU-delegaten. Efter att inferensen utförts läses resultatet från utgångstensorn:

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", "Toppklass: " + bestClass);

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

Exempel på körning på Python för testning före driftsättning. TFLite Python API gör det möjligt att ladda .tflite, utföra inferens och visa resultatet. Används för felsökning och kontroll av modellens noggrannhet:

import tensorflow as tf
import numpy as np

# Ladda TFLite-modellen från fil
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

# Hämta information om in- och utdatatensorer
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Förbered slumpmässig indata för testning
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("Utdataform:", output_data.shape)