TF Lite Delegate : ce que c'est, délégués GPU et NNAPI

Qu'est-ce que TF Lite Delegate : architecture et principe de fonctionnement

TF Lite Delegate est un adaptateur logiciel entre TensorFlow Lite Runtime et l'accélérateur matériel du dispositif. Le délégué intercepte les opérations du graphe du modèle (convolutions, pooling, multiplications matricielles) et les exécute sur une unité de calcul spécialisée au lieu du CPU. Si le délégué ne prend pas en charge une opération particulière, elle s'exécute sur le CPU — c'est ce qu'on appelle la délégation partielle.

Architecture de TF Lite Delegate est construite autour de l'interface SimpleDelegate API et de la structure TfLiteDelegate en C++. Chaque délégué implémente des méthodes de délégation des nœuds du graphe, d'allocation mémoire et d'exécution sur le dispositif cible. Le développeur connecte le délégué via Interpreter::ModifyGraphWithDelegate avant d'appeler Invoke. Selon le Guide TensorFlow, le délégué est appliqué automatiquement à toutes les opérations prises en charge du modèle.

Vérification de compatibilité est une étape obligatoire. Toutes les opérations ne sont pas prises en charge par chaque délégué. TensorFlow Lite fournit l'outil Delegation Compatibility Check : exécutez le modèle avec le délégué et vérifiez combien d'opérations (ops) sont déléguées. Si moins de 80 % sont déléguées, envisagez de choisir un autre délégué ou de rester sur le CPU. Selon TensorFlow (2025), GPU Delegate prend en charge 45 opérations, NNAPI — 60+.

Dans les projets IT Sectr, nous utilisons les délégués GPU pour iOS et XNNPACK pour Android avec vérification de compatibilité intégrée : le modèle est testé sur tous les délégués, en sélectionnant le plus rapide avec au moins 90 % de délégation complète.

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

Vérification des opérations déléguées — contrôle de compatibilité via Interpreter. Par défaut, le délégué accepte toutes les opérations qu'il prend en charge. Pour le débogage, utilisez la journalisation du nombre de nœuds délégués. Si le modèle contient des opérations personnalisées (custom ops), le délégué ne les accélère pas mais ne les casse pas non plus — elles s'exécutent sur le CPU.

// Vérifier le nombre d'opérations déléguées
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Déléguées : $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Seuil de 80 % — choisissez un autre délégué
}

GPU Delegate : accélération sur le processeur graphique

GPU Delegate est un délégué TensorFlow Lite pour exécuter des modèles sur le GPU via OpenGL ES 3.1+ (Android) ou Metal (iOS). Les processeurs graphiques sont optimisés pour les opérations matricielles parallèles — Core ML et les réseaux neuronaux convolutifs (CNN) en bénéficient le plus. GPU Delegate réduit la latence d'inférence de 4 à 8 fois pour des modèles comme MobileNet, EfficientNet, Inception.

Limitations de GPU Delegate : ne prend pas en charge toutes les opérations (seulement 45 sur ~120 dans TF Lite), nécessite OpenGL ES 3.1 ou Metal, consomme plus d'énergie que le CPU. Le GPU est inefficace pour une taille de lot > 1 dans les scénarios mobiles. Selon les benchmarks TensorFlow (2025), sur Pixel 8 avec GPU Adreno 740, MobileNetV2 s'exécute en 4,2 ms sur GPU contre 18,7 ms sur CPU — une accélération de 4,4x.

Configuration de GPU Delegate inclut la sélection de précision : float16 réduit la précision mais accélère l'inférence de 30 à 40 % sans perte de qualité notable (pour la plupart des tâches). Activez allow_precision_loss=true pour des performances GPU maximales. Pour les tâches de haute précision (médecine, finance), utilisez float32.

// GPU Delegate avec optimisation de précision
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate sur iOS utilise Metal Performance Shaders via Metal Delegate. Sur iOS, le délégué fonctionne via le délégué Core ML pour Apple Neural Engine ou Metal directement. Apple A17 Pro exécute MobileNetV2 en 1,3 ms — 6 fois plus rapide que le CPU. Metal delegate est disponible depuis iOS 12 et prend en charge tous les appareils avec puce A7+.

NNAPI Delegate : réseaux neuronaux sur Android via Neural Networks API

NNAPI Delegate (Android Neural Networks API) est un délégué TF Lite qui utilise l'accélération matérielle via Android NN HAL (Hardware Abstraction Layer). NNAPI redirige les opérations du modèle vers NPU, DSP ou GPU selon les pilotes disponibles du dispositif. Pris en charge sur Android 8.1+ (API 27+) et est le délégué recommandé par défaut pour Android.

Avantage de NNAPI — sélection automatique de l'accélérateur. Si le dispositif dispose d'un NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI lui délègue les opérations. Si aucun NPU — vers GPU via OpenCL. Si GPU n'est pas non plus pris en charge — vers CPU avec optimisations DSP. Le développeur ne spécifie pas d'accélérateur particulier — NNAPI sélectionne l'optimal. Selon Google I/O 2024, le délégué NNAPI sur Snapdragon 8 Gen 3 accélère les modèles LLM 12 fois.

Limitations de NNAPI : prise en charge inégale sur différents appareils. Les anciens appareils (Android 8.1) ont un ensemble limité de pilotes. Huawei avec Kirin ne prend pas en charge NNAPI via Google Services — utilisez GPU Delegate. Pour une compatibilité garantie, Google recommande NNAPI Delegate comme premier choix, avec repli sur GPU ou XNNPACK.

// NNAPI Delegate avec repli CPU
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = sélection automatique
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

Nom de l'accélérateur NNAPI — un paramètre pour la sélection explicite de l'accélérateur. Si null est passé, NNAPI sélectionne automatiquement. Pour les tests, spécifiez un accélérateur concret : "qti", "google-edgetpu", "mediatek". La liste des accélérateurs disponibles est obtenue via NnApiDelegate.getAvailableAccelerators(). En production, utilisez la sélection automatique avec un seuil de compatibilité.

XNNPACK Delegate : optimisation CPU via SIMD

XNNPACK Delegate est un délégué TensorFlow Lite pour l'exécution optimisée sur CPU via les instructions SIMD (ARM NEON, SSE, AVX). XNNPACK ne nécessite ni GPU ni NPU — c'est un délégué CPU pur, mais avec une accélération de 2 à 4 fois grâce à SIMD, la fusion d'opérateurs, la prélecture mémoire et l'inférence quantifiée (INT8). Idéal pour les appareils sans NPU dédié ou lorsque la compatibilité garantie est nécessaire.

XNNPACK a été développé par Google comme délégué TF Lite par défaut pour le CPU (inclus dans TFLite Runtime par défaut). Il prend en charge 90+ opérations — plus que GPU ou NNAPI. XNNPACK est particulièrement efficace pour les modèles quantifiés (INT8, INT16) : les opérations s'exécutent 2 à 3 fois plus vite que la version float32. Selon les benchmarks Google (2025), XNNPACK accélère INT8 MobileNetV2 de 2,8x par rapport au CPU de base.

XNNPACK vs GPU : sur les appareils sans NPU, XNNPACK est souvent plus rapide que GPU Delegate pour les petits lots (1–4) — le GPU a un surcoût de transfert de données entre CPU et GPU. XNNPACK opère dans le même espace d'adressage CPU — pas de copie mémoire. Pour les modèles jusqu'à 5 Mo, XNNPACK peut être plus rapide que GPU. Pour les grands modèles CNN, le GPU l'emporte grâce au parallélisme.

// XNNPACK Delegate activé par défaut dans TFLite 2.18+
// Utilisation explicite via 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)
})

Drapeaux XNNPACK : USE_XNNPACK — active forcément le délégué, FLUSH_TO_ZERO — traite les nombres dénormalisés pour l'accélération, ENABLE_XNNPACK_SHAPES — tailles d'entrée dynamiques. Pour une compatibilité maximale, utilisez les options par défaut. Si des erreurs se produisent sur des appareils anciens, désactivez XNNPACK — le modèle fonctionne toujours sur CPU mais plus lentement.

Core ML et Metal Delegate : accélération sur iOS

Core ML Delegate est un délégué TensorFlow Lite pour iOS qui utilise Apple Core ML Framework. Core ML convertit le modèle TF Lite au format .mlmodel et l'exécute sur Apple Neural Engine (ANE), GPU (Metal) ou CPU. Apple A17 Pro et M3 disposent d'un Neural Engine dédié que Core ML utilise automatiquement. Core ML Delegate accélère l'inférence de 5 à 10 fois par rapport au CPU sur les appareils iOS modernes.

Core ML sur iOS prend en charge flex delegate (délégation dynamique des opérations disponibles pour Core ML) et la conversion complète du modèle (conversion de l'ensemble du modèle en .mlmodel). Apple recommande flex delegate — il est plus rapide car il fonctionne à l'exécution sans conversion préalable. Core ML Delegate prend en charge les modèles float32, float16 et quantifiés (INT8).

Metal Delegate est un délégué de plus bas niveau qui fonctionne directement avec Metal Performance Shaders. Utilisez Metal lorsque Core ML ne prend pas en charge des opérations spécifiques. Metal Delegate offre un contrôle maximal sur le GPU mais nécessite plus de code. Selon Apple (WWDC 2024), Metal Delegate pour les modèles Swift natifs peut être 15 à 20 % plus rapide que Core ML en raison de l'absence de surcoût de conversion.

// Core ML Delegate sur iOS via 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)

Choix entre Core ML et Metal : Core ML pour la production, Metal pour les cas extrêmes. Core ML gère automatiquement la mémoire NE, prend en charge le repli sur CPU (fallback) et ne nécessite pas de conversion manuelle. Metal offre un contrôle sur les tampons et convient aux opérations personnalisées. Dans les projets IT Sectr, nous utilisons Core ML Delegate pour tous les modèles iOS et Metal uniquement pour les tâches d'analyse vidéo en temps réel.

Comment choisir un délégué pour votre projet

Choix d'un TF Lite Delegate dépend de la plateforme cible, du modèle et des exigences de latence. Il n'existe pas de délégué universellement meilleur — chacun a des forces et des faiblesses. La stratégie optimale : tester tous les délégués disponibles sur le dispositif cible et choisir le minimalement rapide — pas le plus rapide, mais le minimalement suffisant.

Recommandations par choix : pour Android avec NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Pour Android sans NPU — XNNPACK Delegate (par défaut). Pour iOS — Core ML Delegate. Pour les projets multiplateformes, utilisez la stratégie : NNAPI sur Android, Core ML sur iOS, XNNPACK comme repli. GPU Delegate — lorsque NNAPI n'est pas disponible et que XNNPACK n'est pas assez rapide.

Tests de latence sont une étape obligatoire de la sélection. Mesurez l'inférence à température minimale (appareil froid) et après 5 minutes de fonctionnement continu (thermal throttling). GPU et NNAPI peuvent réduire les performances lorsqu'ils chauffent. XNNPACK (CPU) est moins affecté. Utilisez TensorFlow Lite Benchmark Tool pour des tests automatiques de tous les délégués sur votre appareil.

// Stratégie de sélection de délégué
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Stratégie de repli — chargez le modèle sans exceptions : si le délégué n'est pas pris en charge, exécutez sur CPU. TensorFlow Lite lance IllegalArgumentException en cas d'erreur de création du délégué. Enveloppez la création du délégué dans try-catch et exécutez le modèle sans délégué en cas d'erreur. Une IA lente mais fonctionnelle est meilleure qu'une erreur pour l'utilisateur.