L'utilisation d'unités de traitement graphique (GPU) pour exécuter vos modèles de machine learning (ML) peut améliorer considérablement les performances de votre modèle et l'expérience utilisateur de vos applications compatibles avec le ML. TensorFlow Lite permet d'utiliser des GPU et d'autres processeurs spécialisés via un pilote matériel appelé délégués. L'activation de l'utilisation de GPU avec vos applications ML TensorFlow Lite peut offrir les avantages suivants:
- Rapidité : les GPU sont conçus pour un débit élevé pour des charges de travail massivement parallèles. Cette conception convient parfaitement aux réseaux de neurones profonds, qui consistent en un grand nombre d'opérateurs, chacun travaillant sur des Tensors d'entrée pouvant être traités en parallèle, ce qui entraîne généralement une latence inférieure. Dans le meilleur des scénarios, l'exécution du modèle sur un GPU peut s'exécuter suffisamment rapidement pour permettre des applications en temps réel qui n'étaient pas possibles auparavant.
- Efficacité énergétique : les GPU effectuent des calculs de ML de manière très efficace et optimisée. Ils consomment généralement moins d'énergie et génèrent moins de chaleur que la même tâche exécutée sur les processeurs.
Ce document présente la compatibilité des GPU dans TensorFlow Lite, ainsi que certaines utilisations avancées des processeurs GPU. Pour en savoir plus sur la prise en charge des GPU sur des plates-formes spécifiques, consultez les guides suivants:
Compatibilité avec les opérations GPU ML
Le délégué de GPU TensorFlow Lite peut accélérer certaines opérations TensorFlow ML, ou opérations, qui sont soumises à certaines limites. Le délégué prend en charge les opérations suivantes avec une précision à virgule flottante 16 et 32 bits:
ADD
AVERAGE_POOL_2D
CONCATENATION
CONV_2D
DEPTHWISE_CONV_2D v1-2
EXP
FULLY_CONNECTED
LOGICAL_AND
LOGISTIC
LSTM v2 (Basic LSTM only)
MAX_POOL_2D
MAXIMUM
MINIMUM
MUL
PAD
PRELU
RELU
RELU6
RESHAPE
RESIZE_BILINEAR v1-3
SOFTMAX
STRIDED_SLICE
SUB
TRANSPOSE_CONV
Par défaut, toutes les opérations ne sont compatibles qu'avec la version 1. L'activation de la prise en charge de la quantification active les versions appropriées (par exemple, ADD v2).
Résoudre les problèmes liés aux GPU
Si certaines opérations ne sont pas compatibles avec le délégué GPU, le framework n'exécute qu'une partie du graphique sur le GPU et l'autre partie sur le processeur. En raison du coût élevé de la synchronisation processeur/GPU, un mode d'exécution fractionné tel que celui-ci entraîne souvent des performances plus lentes que lorsque l'ensemble du réseau est exécuté uniquement sur le processeur. Dans ce cas, l'application génère un avertissement, par exemple:
WARNING: op code #42 cannot be handled by this delegate.
Il n'existe pas de rappel pour les échecs de ce type, car il ne s'agit pas d'un échec d'exécution réel. Lorsque vous testez l'exécution de votre modèle avec le délégué de GPU, vous devez être attentif à ces avertissements. Un nombre élevé d'avertissements peut indiquer que votre modèle n'est pas adapté à l'accélération du GPU et peut nécessiter une refactorisation.
Exemples de modèles
Les exemples de modèles suivants sont conçus pour exploiter l'accélération GPU avec TensorFlow Lite. Ils sont fournis à titre de référence et à des fins de test:
- Classification d'images MobileNet v1 (224x224)
- Modèle de classification d'images conçu pour les applications de vision mobile et intégrées. (model)
- Segmentation DeepLab
(257 x 257)
- modèle de segmentation d'image qui attribue des étiquettes sémantiques (telles qu'un chien, un chat ou une voiture) à chaque pixel de l'image d'entrée. (model)
- Détection d'objets SSD MobileNet
- Un modèle de classification d'images qui détecte plusieurs objets avec des cadres de délimitation. (model)
- PoseNet pour l'estimation des postures
- Un modèle de vision qui estime la posture des personnes dans une image ou une vidéo. (model)
Optimiser pour les GPU
Les techniques suivantes peuvent vous aider à obtenir de meilleures performances lorsque vous exécutez des modèles sur du matériel GPU à l'aide du délégué de GPU TensorFlow Lite:
Opérations de redimensionnement : certaines opérations rapides sur un processeur peuvent avoir un coût élevé pour le GPU sur les appareils mobiles. Les opérations de remodelage sont particulièrement coûteuses à exécuter, y compris
BATCH_TO_SPACE
,SPACE_TO_BATCH
,SPACE_TO_DEPTH
, etc. Vous devez examiner de près l'utilisation des opérations de remodelage et prendre en compte qu'elles n'ont pu être appliquées que pour l'exploration des données ou pour les premières itérations de votre modèle. Leur suppression peut améliorer considérablement les performances.Canaux de données d'image : sur un GPU, les données de Tensor sont réparties en quatre canaux. Ainsi, un calcul sur un Tensor ayant la forme
[B,H,W,5]
fonctionne à peu près de la même manière sur un Tensor de forme[B,H,W,8]
, mais beaucoup moins bien que[B,H,W,4]
. Si le matériel photo que vous utilisez est compatible avec les images RVBA, l'envoi de cette entrée à quatre canaux est beaucoup plus rapide, car cela évite une copie de la mémoire du RVB à 3 canaux vers le RGBX à 4 canaux.Modèles optimisés pour les mobiles : pour obtenir de meilleures performances, vous devez envisager de réentraîner votre classificateur avec une architecture réseau optimisée pour les mobiles. L'optimisation de l'inférence sur l'appareil peut considérablement réduire la latence et la consommation d'énergie en tirant parti des fonctionnalités matérielles mobiles.
Compatibilité avancée avec les GPU
Vous pouvez utiliser d'autres techniques avancées avec le traitement GPU pour améliorer les performances de vos modèles, y compris la quantification et la sérialisation. Les sections suivantes décrivent ces techniques plus en détail.
Utiliser des modèles quantifiés
Cette section explique comment le délégué de GPU accélère les modèles quantifiés 8 bits, par exemple:
- Modèles entraînés avec l'entraînement basé sur la quantification
- Quantification de plage dynamique post-entraînement
- Quantification entière post-entraînement
Pour optimiser les performances, utilisez des modèles comportant des Tensors d'entrée et de sortie à virgule flottante.
Comment ça marche ?
Étant donné que le backend GPU n'accepte que l'exécution à virgule flottante, nous exécutons des modèles quantifiés en lui donnant une "vue à virgule flottante" du modèle d'origine. De manière générale, cela implique les étapes suivantes:
Les Tensors constants (tels que les pondérations/biais) sont déquantifiés une fois dans la mémoire du GPU. Cette opération se produit lorsque le délégué est activé pour TensorFlow Lite.
Les entrées et sorties du programme GPU, si elles sont quantifiées sur 8 bits, sont dé-quantifiées et quantifiées (respectivement) pour chaque inférence. Cette opération est effectuée sur le processeur à l'aide des noyaux optimisés de TensorFlow Lite.
Des simulateurs de quantification sont insérés entre les opérations pour imiter un comportement quantifié. Cette approche est nécessaire pour les modèles dans lesquels les opérations s'attendent à ce que les activations suivent les limites apprises lors de la quantification.
Pour en savoir plus sur l'activation de cette fonctionnalité avec le délégué de GPU, consultez les pages suivantes:
- Utiliser des modèles quantifiés avec GPU sur Android
- Utiliser des modèles quantifiés avec GPU sur iOS
Réduire le temps d'initialisation grâce à la sérialisation
La fonctionnalité de délégation de GPU vous permet de charger à partir du code du noyau précompilé et des données de modèle sérialisées et enregistrées sur le disque lors d'exécutions précédentes. Cette approche évite la recompilation et peut réduire le temps de démarrage jusqu'à 90%. Cette amélioration est obtenue en échangeant de l'espace disque pour gagner du temps. Vous pouvez activer cette fonctionnalité avec quelques options de configuration, comme indiqué dans les exemples de code suivants:
C++
TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default(); options.experimental_flags |= TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_SERIALIZATION; options.serialization_dir = kTmpDir; options.model_token = kModelToken; auto* delegate = TfLiteGpuDelegateV2Create(options); if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
Java
GpuDelegate delegate = new GpuDelegate( new GpuDelegate.Options().setSerializationParams( /* serializationDir= */ serializationDir, /* modelToken= */ modelToken)); Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
Lorsque vous utilisez la fonctionnalité de sérialisation, assurez-vous que votre code respecte les règles d'implémentation suivantes:
- Stockez les données de sérialisation dans un répertoire auquel les autres applications n'ont pas accès. Sur les appareils Android, utilisez
getCodeCacheDir()
, qui pointe vers un emplacement privé pour l'application actuelle. - Le jeton de modèle doit être unique à l'appareil pour le modèle spécifique. Vous pouvez calculer un jeton de modèle en générant une empreinte à partir des données du modèle à l'aide de bibliothèques telles que
farmhash::Fingerprint64
.