TF Lite Delegate: Was es ist, GPU- und NNAPI-Delegaten

Was ist TF Lite Delegate: Architektur und Funktionsprinzip

TF Lite Delegate ist ein Software-Adapter zwischen TensorFlow Lite Runtime und dem Hardwarebeschleuniger des Geräts. Der Delegat fängt Modellgraph-Operationen (Faltungen, Pooling, Matrixmultiplikationen) ab und führt sie auf einer spezialisierten Recheneinheit statt auf der CPU aus. Wenn der Delegat eine bestimmte Operation nicht unterstützt, wird sie auf der CPU ausgeführt — dies wird als partielle Delegation bezeichnet.

TF Lite Delegate-Architektur basiert auf der SimpleDelegate API-Schnittstelle und der TfLiteDelegate-Struktur in C++. Jeder Delegat implementiert Methoden zur Delegation von Graphknoten, Speicherzuweisung und Ausführung auf dem Zielgerät. Der Entwickler verbindet den Delegaten über Interpreter::ModifyGraphWithDelegate vor dem Aufruf von Invoke. Laut TensorFlow Guide wird der Delegat automatisch auf alle unterstützten Modelloperationen angewendet.

Kompatibilitätsprüfung ist ein obligatorischer Schritt. Nicht alle Operationen werden von jedem Delegaten unterstützt. TensorFlow Lite bietet das Tool Delegation Compatibility Check: Führen Sie das Modell mit dem Delegaten aus und prüfen Sie, wie viele Operationen (Ops) delegiert wurden. Wenn weniger als 80% delegiert sind, sollten Sie einen anderen Delegaten wählen oder bei der CPU bleiben. Laut TensorFlow (2025) unterstützt GPU Delegate 45 Operationen, NNAPI — 60+.

In IT Sectr-Projekten verwenden wir GPU-Delegaten für iOS und XNNPACK für Android mit integrierter Kompatibilitätsprüfung: Das Modell wird auf allen Delegaten getestet und der schnellste mit mindestens 90% Delegationsvollständigkeit ausgewählt.

// GPU Delegate-Verbindung auf Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Überprüfung delegierter Operationen — Kompatibilitätskontrolle über Interpreter. Standardmäßig akzeptiert der Delegat alle von ihm unterstützten Operationen. Verwenden Sie zum Debuggen die Protokollierung der Anzahl delegierter Knoten. Enthält das Modell benutzerdefinierte Operationen (Custom Ops), beschleunigt der Delegat sie nicht, bricht sie aber auch nicht — sie werden auf der CPU ausgeführt.

// Anzahl delegierter Operationen prüfen
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegiert: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // 80%-Schwelle — anderen Delegaten wählen
}

GPU Delegate: Beschleunigung auf dem Grafikprozessor

GPU Delegate ist ein TensorFlow Lite-Delegat zur Ausführung von Modellen auf der GPU über OpenGL ES 3.1+ (Android) oder Metal (iOS). Grafikprozessoren sind für parallele Matrixoperationen optimiert — Core ML und faltende neuronale Netze (CNN) profitieren am meisten. GPU Delegate reduziert die Inferenzlatenz um das 4–8-fache für Modelle wie MobileNet, EfficientNet, Inception.

Einschränkungen von GPU Delegate: Unterstützt nicht alle Operationen (nur 45 von ~120 in TF Lite), erfordert OpenGL ES 3.1 oder Metal, verbraucht mehr Energie als die CPU. GPU ist für Batch-Größen > 1 in mobilen Szenarien ineffizient. Laut TensorFlow-Benchmarks (2025) läuft MobileNetV2 auf dem Pixel 8 mit Adreno 740 GPU in 4,2 ms auf der GPU gegenüber 18,7 ms auf der CPU — eine 4,4-fache Beschleunigung.

GPU Delegate-Konfiguration umfasst die Präzisionsauswahl: float16 reduziert die Genauigkeit, beschleunigt aber die Inferenz um 30–40% ohne merklichen Qualitätsverlust (für die meisten Aufgaben). Aktivieren Sie allow_precision_loss=true für maximale GPU-Leistung. Verwenden Sie für hochpräzise Aufgaben (Medizin, Finanzen) float32.

// GPU Delegate mit Präzisionsoptimierung
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate auf iOS verwendet Metal Performance Shaders über Metal Delegate. Auf iOS arbeitet der Delegat über den Core ML-Delegaten für Apple Neural Engine oder direkt über Metal. Apple A17 Pro führt MobileNetV2 in 1,3 ms aus — 6-mal schneller als die CPU. Metal Delegate ist seit iOS 12 verfügbar und unterstützt alle Geräte mit A7+-Chip.

NNAPI Delegate: Neuronale Netze auf Android über Neural Networks API

NNAPI Delegate (Android Neural Networks API) ist ein TF Lite-Delegat, der Hardwarebeschleunigung über Android NN HAL (Hardware Abstraction Layer) nutzt. NNAPI leitet Modelloperationen je nach verfügbaren Gerätetreibern an NPU, DSP oder GPU weiter. Unterstützt ab Android 8.1+ (API 27+) und ist der standardmäßig empfohlene Delegat für Android.

Vorteil von NNAPI — automatische Beschleunigerauswahl. Wenn das Gerät eine NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU) hat, delegiert NNAPI Operationen dorthin. Wenn keine NPU vorhanden ist — an die GPU über OpenCL. Wenn auch die GPU nicht unterstützt wird — an die CPU mit DSP-Optimierungen. Der Entwickler gibt keinen bestimmten Beschleuniger an — NNAPI wählt den optimalen aus. Laut Google I/O 2024 beschleunigt der NNAPI-Delegat auf Snapdragon 8 Gen 3 LLM-Modelle um das 12-fache.

Einschränkungen von NNAPI: ungleiche Unterstützung auf verschiedenen Geräten. Ältere Geräte (Android 8.1) haben einen begrenzten Treibersatz. Huawei mit Kirin unterstützt NNAPI nicht über Google Services — verwenden Sie GPU Delegate. Für garantierte Kompatibilität empfiehlt Google NNAPI Delegate als erste Wahl mit Fallback auf GPU oder XNNPACK.

// NNAPI Delegate mit CPU-Fallback
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = automatische Auswahl
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

NNAPI-Beschleunigername — ein Parameter für die explizite Beschleunigerauswahl. Wenn null übergeben wird, wählt NNAPI automatisch aus. Geben Sie zum Testen einen bestimmten an: "qti", "google-edgetpu", "mediatek". Die Liste der verfügbaren Beschleuniger wird über NnApiDelegate.getAvailableAccelerators() ausgegeben. Verwenden Sie in der Produktion die automatische Auswahl mit einer Kompatibilitätsschwelle.

XNNPACK Delegate: CPU-Optimierung über SIMD

XNNPACK Delegate ist ein TensorFlow Lite-Delegat für optimierte CPU-Ausführung über SIMD-Anweisungen (ARM NEON, SSE, AVX). XNNPACK benötigt weder GPU noch NPU — es ist ein reiner CPU-Delegat, aber mit 2–4-facher Beschleunigung durch SIMD, Operator-Fusion, Memory-Prefetching und quantisierter Inferenz (INT8). Ideal für Geräte ohne dedizierte NPU oder wenn garantierte Kompatibilität erforderlich ist.

XNNPACK wurde von Google als Standard-TF Lite-Delegat für die CPU entwickelt (standardmäßig in TFLite Runtime enthalten). Es unterstützt 90+ Operationen — mehr als GPU oder NNAPI. XNNPACK ist besonders effektiv für quantisierte Modelle (INT8, INT16): Operationen laufen 2–3-mal schneller als die float32-Version. Laut Google-Benchmarks (2025) beschleunigt XNNPACK INT8 MobileNetV2 um das 2,8-fache gegenüber der Basis-CPU.

XNNPACK vs GPU: Auf Geräten ohne NPU ist XNNPACK oft schneller als GPU Delegate für kleine Batches (1–4) — die GPU hat Overhead bei der Datenübertragung zwischen CPU und GPU. XNNPACK arbeitet im gleichen CPU-Adressraum — kein Speicherkopieren. Für Modelle bis 5 MB kann XNNPACK schneller sein als die GPU. Für große CNN-Modelle gewinnt die GPU durch Parallelität.

// XNNPACK Delegate standardmäßig in TFLite 2.18+ aktiviert
// Explizite Verwendung über XnnpackDelegate
val xnnpackOptions = XnnpackDelegate.Options().apply {
    numThreads = 4
    flags = XnnpackDelegate.Flags.USE_XNNPACK
}
val delegate = XnnpackDelegate(xnnpackOptions)
val interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
    addDelegate(delegate)
})

XNNPACK-Flags: USE_XNNPACK — erzwingt die Aktivierung des Delegaten, FLUSH_TO_ZERO — behandelt denormalisierte Zahlen zur Beschleunigung, ENABLE_XNNPACK_SHAPES — dynamische Eingabegrößen. Verwenden Sie für maximale Kompatibilität die Standardoptionen. Wenn auf älteren Geräten Fehler auftreten, deaktivieren Sie XNNPACK — das Modell läuft weiterhin auf der CPU, aber langsamer.

Core ML und Metal Delegate: Beschleunigung auf iOS

Core ML Delegate ist ein TensorFlow Lite-Delegat für iOS, der Apple Core ML Framework verwendet. Core ML konvertiert das TF Lite-Modell in das .mlmodel-Format und führt es auf Apple Neural Engine (ANE), GPU (Metal) oder CPU aus. Apple A17 Pro und M3 haben eine dedizierte Neural Engine, die Core ML automatisch nutzt. Core ML Delegate beschleunigt die Inferenz um das 5–10-fache im Vergleich zur CPU auf modernen iOS-Geräten.

Core ML auf iOS unterstützt flex delegate (dynamische Delegation von für Core ML verfügbaren Operationen) und vollständige Modellkonvertierung (Konvertierung des gesamten Modells in .mlmodel). Apple empfiehlt flex delegate — es ist schneller, da es zur Laufzeit ohne vorherige Konvertierung arbeitet. Core ML Delegate unterstützt float32-, float16- und quantisierte Modelle (INT8).

Metal Delegate ist ein delegierter auf niedrigerer Ebene, der direkt mit Metal Performance Shaders arbeitet. Verwenden Sie Metal, wenn Core ML bestimmte Operationen nicht unterstützt. Metal Delegate bietet maximale Kontrolle über die GPU, erfordert aber mehr Code. Laut Apple (WWDC 2024) kann Metal Delegate für native Swift-Modelle aufgrund fehlenden Konvertierungs-Overheads 15–20% schneller sein als Core ML.

// Core ML Delegate auf iOS über TFLite Swift API
import TensorFlowLite

let coreMLDelegate = CoreMLDelegate()
var options = InterpreterOptions()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)
try interpreter.invoke(at: 0)

Wahl zwischen Core ML und Metal: Core ML für die Produktion, Metal für Randfälle. Core ML verwaltet automatisch den NE-Speicher, unterstützt CPU-Fallback und erfordert keine manuelle Konvertierung. Metal bietet Pufferkontrolle und eignet sich für benutzerdefinierte Operationen. In IT Sectr-Projekten verwenden wir Core ML Delegate für alle iOS-Modelle und Metal nur für Echtzeit-Videoanalyseaufgaben.

Wie wählt man einen Delegaten für sein Projekt aus

Auswahl eines TF Lite Delegaten hängt von der Zielplattform, dem Modell und den Latenzanforderungen ab. Es gibt keinen universell besten Delegaten — jeder hat Stärken und Schwächen. Die optimale Strategie: Testen Sie alle verfügbaren Delegaten auf dem Zielgerät und wählen Sie den minimal schnellen — nicht den schnellsten, sondern den minimal ausreichenden.

Empfehlungen zur Auswahl: Für Android mit NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Für Android ohne NPU — XNNPACK Delegate (Standard). Für iOS — Core ML Delegate. Für plattformübergreifende Projekte verwenden Sie die Strategie: NNAPI auf Android, Core ML auf iOS, XNNPACK als Fallback. GPU Delegate — wenn NNAPI nicht verfügbar und XNNPACK nicht schnell genug ist.

Latenztests sind ein obligatorischer Schritt bei der Auswahl. Messen Sie die Inferenz bei minimaler Temperatur (kaltes Gerät) und nach 5 Minuten Dauerbetrieb (thermisches Drosseln). GPU und NNAPI können bei Erwärmung die Leistung verringern. XNNPACK (CPU) ist weniger betroffen. Verwenden Sie TensorFlow Lite Benchmark Tool zum automatischen Testen aller Delegaten auf Ihrem Gerät.

// Delegatenauswahlstrategie
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Fallback-Strategie — Laden Sie das Modell ohne Ausnahmen: Wenn der Delegat nicht unterstützt wird, führen Sie es auf der CPU aus. TensorFlow Lite wirft IllegalArgumentException bei einem Fehler bei der Delegaterstellung. Wickeln Sie die Delegaterstellung in try-catch ein und führen Sie das Modell bei Fehler ohne Delegaten aus. Langsame aber funktionierende KI ist besser als ein Fehler für den Benutzer.