Les délégués permettent l'accélération matérielle des modèles TensorFlow Lite en s'appuyant sur des accélérateurs sur l'appareil tels que le GPU et le processeur de signal numérique (DSP).
Par défaut, TensorFlow Lite utilise des noyaux de processeur optimisés pour l'ensemble d'instructions ARM Neon. Cependant, le processeur est un processeur polyvalent qui n'est pas nécessairement optimisé pour l'arithmétique lourde généralement présente dans les modèles de machine learning (par exemple, les matrices matricielles impliquées dans la convolution et les couches denses).
D'autre part, la plupart des téléphones mobiles modernes contiennent des puces qui gèrent mieux ces opérations lourdes. Leur utilisation pour les opérations de réseaux de neurones offre d'énormes avantages en termes de latence et d'efficacité énergétique. Par exemple, les GPU peuvent offrir une latence jusqu'à cinq fois plus rapide.
Chacun de ces accélérateurs est associé à des API qui permettent d'effectuer des calculs personnalisés, comme OpenCL ou OpenGLES pour le GPU pour mobile. En règle générale, vous devez écrire une grande quantité de code personnalisé pour faire fonctionner un réseau de neurones via ces interfaces. Les choses se compliquent encore davantage lorsque l'on considère que chaque accélérateur a ses avantages et ses inconvénients, et qu'il ne peut pas exécuter toutes les opérations dans un réseau de neurones. L'API Delegate de TensorFlow Lite résout ce problème en faisant le lien entre l'environnement d'exécution TFLite et ces API de niveau inférieur.
Choisir un délégué
TensorFlow Lite accepte plusieurs délégués, chacun étant optimisé pour certaines plates-formes et certains types de modèles. En règle générale, plusieurs délégués s'appliquent à votre cas d'utilisation, en fonction de deux critères principaux : la plate-forme (Android ou iOS) que vous ciblez et le Model-type (à virgule flottante ou quantifiée) que vous essayez d'accélérer.
Délégués par plate-forme
Multiplate-forme (Android et iOS)
- Délégué de GPU : le délégué de GPU peut être utilisé à la fois sur Android et sur iOS. Il est optimisé pour exécuter des modèles à virgule flottante 32 bits et 16 bits lorsqu'un GPU est disponible. Il est également compatible avec les modèles quantifiés 8 bits et offre des performances de GPU équivalentes à celles de leurs versions à virgule flottante. Pour en savoir plus sur le délégué de GPU, consultez TensorFlow Lite sur GPU.
iOS
- Délégué Core ML pour les iPhone et iPad plus récents : pour les iPhone et iPad plus récents sur lesquels Neural Engine est disponible, vous pouvez utiliser le délégué Core ML pour accélérer l'inférence pour les modèles à virgule flottante 32 bits ou 16 bits. Neural Engine est disponible sur les appareils mobiles Apple dotés d'un SoC A12 ou d'une version ultérieure. Pour obtenir une présentation du délégué Core ML et des instructions détaillées, consultez la page Délégué Core ML TensorFlow Lite.
Délégués par type de modèle
Chaque accélérateur est conçu en tenant compte d'une certaine largeur de bits. Si vous fournissez à un délégué un modèle à virgule flottante qui n'accepte que les opérations quantifiées 8 bits, toutes ses opérations seront refusées et le modèle s'exécutera entièrement sur le processeur. Pour éviter de telles surprises, le tableau ci-dessous présente l'assistance déléguée en fonction du type de modèle:
| Type de modèle | GPU | CoreML |
|---|---|---|
| Valeur à virgule flottante (32 bits) | Oui | Oui |
| Quantification float16 post-entraînement | Oui | Oui |
| Quantification de la plage dynamique post-entraînement | Oui | Non |
| Quantification par nombres entiers post-entraînement | Oui | Non |
| Entraînement tenant compte de la quantification | Oui | Non |
Valider les performances
Les informations de cette section servent de base pour sélectionner les délégués susceptibles d'améliorer votre application. Cependant, il est important de noter que chaque délégué dispose d'un ensemble prédéfini d'opérations qu'il accepte et peut fonctionner différemment selon le modèle et l'appareil. Par conséquent, il est généralement recommandé d'effectuer une analyse comparative pour évaluer l'utilité d'un délégué pour vos besoins. Cela permet également de justifier l'augmentation de la taille binaire associée à l'association d'un délégué à l'environnement d'exécution TensorFlow Lite.
TensorFlow Lite dispose d'outils d'évaluation des performances et de la justesse complets qui peuvent permettre aux développeurs d'utiliser des délégués dans leur application en toute confiance. Ces outils sont abordés dans la section suivante.
Outils d'évaluation
Latence et espace mémoire utilisé
L'outil d'analyse comparative de TensorFlow Lite peut être utilisé avec les paramètres appropriés pour estimer les performances du modèle, y compris la latence d'inférence moyenne, la surcharge d'initialisation, l'empreinte mémoire, etc. Cet outil accepte plusieurs indicateurs afin de déterminer la meilleure configuration déléguée pour votre modèle. Par exemple, --gpu_backend=gl peut être spécifié avec --use_gpu pour mesurer l'exécution du GPU avec OpenGL. La liste complète des paramètres de délégation compatibles est définie dans la documentation détaillée.
Voici un exemple d'exécution pour un modèle quantifié avec GPU via adb:
adb shell /data/local/tmp/benchmark_model \
--graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
--use_gpu=true
Vous pouvez télécharger la version prédéfinie de cet outil pour Android, avec l'architecture ARM 64 bits, sur cette page (en savoir plus).
Exactitude et exactitude
Les délégués effectuent généralement des calculs avec une précision différente de celle de leurs homologues du processeur. Par conséquent, l'utilisation d'un délégué pour l'accélération matérielle entraîne un compromis de justesse (généralement mineur). Notez que ce n'est pas toujours vrai. Par exemple, comme le GPU utilise la précision à virgule flottante pour exécuter des modèles quantifiés, la précision peut être légèrement améliorée (par exemple, < 1% d'amélioration de la classification d'images ILSVRC.
TensorFlow Lite dispose de deux types d'outils pour mesurer la précision du comportement d'un délégué pour un modèle donné: les outils basés sur les tâches et les outils Agnostiques sur la tâche. Tous les outils décrits dans cette section sont compatibles avec les paramètres de délégation avancée utilisés par l'outil d'analyse comparative de la section précédente. Notez que les sous-sections ci-dessous se concentrent sur l'évaluation déléguée (le délégué effectue-t-il les mêmes opérations que le processeur ?) plutôt que sur l'évaluation du modèle (le modèle est-il adapté à cette tâche ?).
Évaluation basée sur les tâches
TensorFlow Lite dispose d'outils permettant d'évaluer l'exactitude de deux tâches basées sur des images:
ILSVRC 2012 (classification d'images) avec précision top-K
Détection d'objets COCO (avec cadres de délimitation) avec la précision moyenne (mAP)
Les binaires prédéfinis de ces outils (Android, architecture ARM 64 bits), ainsi que la documentation, sont disponibles ici:
L'exemple ci-dessous illustre l'évaluation de la classification d'images avec un GPU sur un Pixel 4:
adb shell /data/local/tmp/run_eval \
--model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
--ground_truth_images_path=/data/local/tmp/ilsvrc_images \
--ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
--model_output_labels=/data/local/tmp/model_output_labels.txt \
--output_file_path=/data/local/tmp/accuracy_output.txt \
--num_images=0 # Run on all images. \
--use_gpu=true
Le résultat attendu est une liste de métriques top-K de 1 à 10:
Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333
Évaluation agile des tâches
Pour les tâches pour lesquelles il n'existe pas d'outil d'évaluation établi sur l'appareil ou si vous testez des modèles personnalisés, TensorFlow Lite dispose de l'outil Inference Diff (Différence d'inférence). (Pour Android, le binaire d'architecture binaire ARM 64 bits, cliquez ici.)
La différence d'inférence compare l'exécution de TensorFlow Lite (en termes de latence et d'écart des valeurs de sortie) dans deux paramètres:
- Inférence pour les processeurs monothread
- Inférence définie par l'utilisateur - définie par ces paramètres
Pour ce faire, l'outil génère des données gaussiennes aléatoires et les transmet par deux interpréteurs TFLite : l'un exécutant des noyaux de processeur à thread unique, et l'autre paramétré par les arguments de l'utilisateur.
Il mesure la latence des deux, ainsi que la différence absolue entre les Tensors de sortie de chaque interpréteur, pour chaque élément.
Pour un modèle avec un seul Tensor de sortie, la sortie peut se présenter comme suit:
Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06
Cela signifie que pour le Tensor de sortie à l'indice 0, les éléments de la sortie du processeur diffèrent de la sortie déléguée d'une moyenne de 1.96e-05.
Notez que l'interprétation de ces chiffres nécessite une connaissance plus approfondie du modèle et de la signification de chaque Tensor de sortie. S'il s'agit d'une simple régression qui détermine une sorte de score ou de représentation vectorielle continue, la différence doit être faible (sinon, il s'agit d'une erreur au niveau du délégué). Toutefois, les sorties telles que la "classe de détection" des modèles SSD sont un peu plus difficiles à interpréter. Par exemple, il peut afficher une différence à l'aide de cet outil, mais cela ne signifie peut-être pas qu'il y a un problème avec le délégué. Prenons l'exemple de deux classes (fausses) : "TV (ID: 10)", "Monitor (ID: 20)" : si un délégué n'est pas assez fiable et qu'il affiche "Monitor" au lieu de "TV", la différence de sortie pour ce Tensor peut être comprise entre 20 et 10.