Outils d'analyse comparative
Les outils de benchmark TensorFlow Lite mesurent et calculent actuellement les statistiques pour les métriques de performances importantes suivantes:
- Délai d'initialisation
- Temps d'inférence de l'état de préchauffage
- Heure d'inférence de l'état stable
- Utilisation de la mémoire au moment de l'initialisation
- Utilisation globale de la mémoire
Les outils d'analyse comparative sont disponibles en tant qu'applications de benchmark pour Android et iOS et sous forme de binaires de ligne de commande natifs. Ils partagent tous la même logique de mesure des performances de base. Notez que les options et les formats de sortie disponibles sont légèrement différents en raison des différences d'environnement d'exécution.
Application de benchmark Android
Pour utiliser l'outil d'analyse comparative avec Android, deux possibilités s'offrent à vous. L'un est un binaire de benchmark natif et l'autre est une application de benchmark Android, une meilleure évaluation des performances du modèle dans l'application. Dans tous les cas, les chiffres de l'outil de benchmark seront toujours légèrement différents de ceux obtenus lors de l'exécution d'inférences avec le modèle dans l'application réelle.
Cette application d'analyse comparative Android n'a pas d'interface utilisateur. Installez et exécutez-le à l'aide de la commande adb, puis récupérez les résultats à l'aide de la commande adb logcat.
Télécharger ou créer l'application
Téléchargez les applications de benchmark Android prédéfinies à l'aide des liens ci-dessous:
En ce qui concerne les applications de benchmark Android compatibles avec les opérations TF via un délégué Flex, utilisez les liens ci-dessous:
Vous pouvez également créer l'application à partir de la source en suivant instructions.
Préparer le benchmark
Avant d'exécuter l'application de benchmark, installez-la et envoyez le fichier de modèle à l'appareil comme suit:
adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp
Exécuter l'analyse comparative
adb shell am start -S \
-n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
--es args '"--graph=/data/local/tmp/your_model.tflite \
--num_threads=4"'
Le paramètre graph est obligatoire.
graph:string
Chemin d'accès au fichier de modèle TFLite.
Vous pouvez spécifier davantage de paramètres facultatifs pour exécuter l'analyse comparative.
num_threads:int(par défaut=1)
Nombre de threads à utiliser pour exécuter l'interpréteur TFLite.use_gpu:bool(par défaut=faux)
Utilisez le délégué de GPU.use_xnnpack:bool(par défaut=false)
Utilisez le délégué XNNPACK.
Selon l'appareil que vous utilisez, certaines de ces options peuvent ne pas être disponibles ou n'avoir aucun effet. Reportez-vous à la section Paramètres pour en savoir plus sur les paramètres de performances que vous pouvez exécuter avec l'application de benchmark.
Affichez les résultats à l'aide de la commande logcat:
adb logcat | grep "Inference timings"
Les résultats du benchmark sont présentés comme suit:
... tflite : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2
Binaire de benchmark natif
L'outil d'analyse comparative est également fourni en tant que benchmark_model binaire natif. Vous pouvez exécuter cet outil à partir d'une ligne de commande shell sur Linux, Mac, les appareils embarqués et les appareils Android.
Télécharger ou compiler le binaire
Téléchargez les binaires natifs de ligne de commande prédéfinis la nuit en suivant les liens ci-dessous:
En ce qui concerne les binaires nocturnes prédéfinis compatibles avec les opérations TF via un délégué Flex, utilisez les liens ci-dessous:
Vous pouvez également créer le binaire de benchmark natif à partir de la source sur votre ordinateur.
bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model
Pour compiler avec la chaîne d'outils du NDK Android, vous devez d'abord configurer l'environnement de compilation en suivant ce guide ou utiliser l'image Docker comme décrit dans ce guide.
bazel build -c opt --config=android_arm64 \
//tensorflow/lite/tools/benchmark:benchmark_model
Exécuter l'analyse comparative
Pour exécuter des analyses comparatives sur votre ordinateur, exécutez le binaire à partir du shell.
path/to/downloaded_or_built/benchmark_model \
--graph=your_model.tflite \
--num_threads=4
Vous pouvez utiliser le même ensemble de paramètres que celui mentionné ci-dessus avec le binaire de ligne de commande natif.
Profiler des opérations de modèle
Le binaire du modèle de benchmark vous permet également de profiler les opérations du modèle et d'obtenir les temps d'exécution de chaque opérateur. Pour ce faire, transmettez l'option --enable_op_profiling=true à benchmark_model lors de l'appel. Pour en savoir plus, cliquez ici.
Binaire de benchmark natif pour plusieurs options de performances en une seule exécution
Un binaire C++ pratique et simple est également fourni pour analyser plusieurs options de performances en une seule exécution. Ce binaire est basé sur l'outil d'analyse comparative mentionné ci-dessus, qui ne peut comparer qu'une seule option de performances à la fois. Ils partagent le même processus de compilation, d'installation et d'exécution, mais le nom de la cible BUILD de ce binaire est benchmark_model_performance_options et nécessite des paramètres supplémentaires.
Un paramètre important pour ce binaire est:
perf_options_list: string (default='all')
Liste d'options de performances TFLite à comparer, séparées par une virgule.
Vous pouvez obtenir les binaires précompilés de nuit pour cet outil comme indiqué ci-dessous:
Application de benchmark iOS
Pour exécuter des analyses comparatives sur un appareil iOS, vous devez compiler l'application à partir de la source.
Placez le fichier de modèle TensorFlow Lite dans le répertoire benchmark_data de l'arborescence source, puis modifiez le fichier benchmark_params.json. Ces fichiers sont empaquetés dans l'application, qui lit les données dans le répertoire. Pour obtenir des instructions détaillées, consultez l'application benchmark iOS.
Benchmarks de performances pour des modèles bien connus
Cette section présente les benchmarks de performances TensorFlow Lite lors de l'exécution de modèles connus sur certains appareils Android et iOS.
Benchmarks des performances Android
Ces chiffres de benchmark des performances ont été générés avec le binaire de benchmark natif.
Pour les benchmarks Android, l'affinité de processeur est configurée pour utiliser de grands cœurs sur l'appareil afin de réduire la variance (voir les détails).
Nous partons du principe que les modèles ont été téléchargés et décompressés dans le répertoire /data/local/tmp/tflite_models. Le binaire de benchmark est créé en suivant ces instructions et supposé se trouver dans le répertoire /data/local/tmp.
Pour exécuter l'analyse comparative:
adb shell /data/local/tmp/benchmark_model \
--num_threads=4 \
--graph=/data/local/tmp/tflite_models/${GRAPH} \
--warmup_runs=1 \
--num_runs=50
Pour exécuter avec un délégué de GPU, définissez --use_gpu=true.
Les valeurs de performances ci-dessous sont mesurées sur Android 10.
| Nom du modèle | Appareil | Processeur, 4 threads | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | Pixel 3 | 23,9 ms | 6,45 ms |
| Pixel 4 | 14 ms | 9 ms | |
| Mobilenet_1.0_224 (quant) | Pixel 3 | 13,4 ms | --- |
| Pixel 4 | 5 ms | --- | |
| NASNet Mobile | Pixel 3 | 56 ms | --- |
| Pixel 4 | 34,5 ms | --- | |
| SqueezeNet | Pixel 3 | 35,8 ms | 9,5 ms |
| Pixel 4 | 23,9 ms | 11,1 ms | |
| Inception_ResNet_V2 | Pixel 3 | 422 ms | 99,8 ms |
| Pixel 4 | 272,6 ms | 87,2 ms | |
| Inception_V4 | Pixel 3 | 486 ms | 93 ms |
| Pixel 4 | 324,1 ms | 97,6 ms |
Benchmarks des performances iOS
Ces chiffres de benchmark des performances ont été générés avec l'application de benchmark iOS.
Pour exécuter des analyses comparatives iOS, l'application de benchmark a été modifiée afin d'inclure le modèle approprié, et benchmark_params.json a été modifié pour définir num_threads sur 2. Pour utiliser le délégué GPU, les options "use_gpu" : "1" et "gpu_wait_type" : "aggressive" ont également été ajoutées à benchmark_params.json.
| Nom du modèle | Appareil | Processeur, 2 threads | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | iPhone XS | 14,8 ms | 3,4 ms |
| Mobilenet_1.0_224 (quant) | iPhone XS | 11 ms | --- |
| NASNet Mobile | iPhone XS | 30,4 ms | --- |
| SqueezeNet | iPhone XS | 21,1 ms | 15,5 ms |
| Inception_ResNet_V2 | iPhone XS | 261,1 ms | 45,7 ms |
| Inception_V4 | iPhone XS | 309 ms | 54,4 ms |
Tracer les composants internes de TensorFlow Lite
Tracer les composants internes de TensorFlow Lite dans Android
Les événements internes de l'interpréteur TensorFlow Lite d'une application Android peuvent être capturés par les outils de traçage Android. Il s'agit des mêmes événements que l'API Trace d'Android. Par conséquent, les événements capturés à partir du code Java/Kotlin sont visibles avec les événements internes TensorFlow Lite.
Voici quelques exemples d'événements:
- Appel de l'opérateur
- Modification de graphe par délégué
- Allocation de Tensors
Parmi les différentes options de capture de traces, ce guide présente le Profileur de processeur et l'application de traçage système d'Android Studio. Reportez-vous à l'outil de ligne de commande Perfetto ou à l'outil de ligne de commande Systrace pour connaître les autres options disponibles.
Ajouter des événements de trace en code Java
Il s'agit d'un extrait de code de l'exemple d'application Classification d'images. L'interpréteur TensorFlow Lite s'exécute dans la section recognizeImage/runInference. Cette étape est facultative, mais elle permet de savoir où l'appel d'inférence a lieu.
Trace.beginSection("recognizeImage");
...
// Runs the inference call.
Trace.beginSection("runInference");
tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
Trace.endSection();
...
Trace.endSection();
Activer le traçage TensorFlow Lite
Pour activer le traçage TensorFlow Lite, définissez la propriété système Android debug.tflite.trace sur 1 avant de démarrer l'application Android.
adb shell setprop debug.tflite.trace 1
Si cette propriété a été définie lors de l'initialisation de l'interpréteur TensorFlow Lite, les événements clés (appel d'opérateur, par exemple) de l'interpréteur seront tracés.
Après avoir capturé toutes les traces, désactivez le traçage en définissant la valeur de la propriété sur 0.
adb shell setprop debug.tflite.trace 0
Profileur de processeur Android Studio
Pour capturer des traces avec le Profileur de processeur Android Studio, procédez comme suit:
Sélectionnez Run > Profile 'app' (Exécuter > Profil "application") dans les menus du haut.
Cliquez n'importe où dans la chronologie du processeur lorsque la fenêtre de Profiler apparaît.
Sélectionnez "Trace System Calls" (Tracer les appels système) parmi les modes de profilage du processeur.
Appuyez sur le bouton "Enregistrer".
Appuyez sur le bouton "Arrêter".
Examinez le résultat de la trace.
Dans cet exemple, vous pouvez voir la hiérarchie des événements dans un thread et les statistiques pour chaque heure de l'opérateur, ainsi que le flux de données de l'ensemble de l'application entre les threads.
Application de traçage système
Capturez des traces sans Android Studio en suivant les étapes détaillées dans la section Application de traçage système.
Dans cet exemple, les mêmes événements TFLite ont été capturés et enregistrés au format Perfetto ou Systrace, en fonction de la version de l'appareil Android. Les fichiers de suivi capturés peuvent être ouverts dans l'interface utilisateur de Perfetto.
Tracer les composants internes de TensorFlow Lite dans iOS
Les événements internes de l'interpréteur TensorFlow Lite d'une application iOS peuvent être capturés par l'outil Instruments inclus avec Xcode. Il s'agit des événements d'affichage de panneau iOS. Les événements capturés à partir du code Swift/Objective-C sont vus avec les événements internes de TensorFlow Lite.
Voici quelques exemples d'événements:
- Appel de l'opérateur
- Modification de graphe par délégué
- Allocation de Tensors
Activer le traçage TensorFlow Lite
Définissez la variable d'environnement debug.tflite.trace en procédant comme suit:
Sélectionnez Product > Scheme > Edit Scheme (Produit > Schéma > Modifier le schéma) dans les menus supérieurs de Xcode.
Cliquez sur "Profil" dans le volet de gauche.
Décochez la case "Utiliser les arguments et les variables d'environnement de l'action d'exécution".
Ajoutez
debug.tflite.tracesous la section "Variables d'environnement".
Si vous souhaitez exclure les événements TensorFlow Lite lors du profilage de l'application iOS, désactivez le traçage en supprimant la variable d'environnement.
Instruments XCode
Pour capturer des traces, procédez comme suit:
Sélectionnez Product > Profile (Produit > Profil) dans les menus supérieurs de Xcode.
Cliquez sur Logging (Journalisation) parmi les modèles de profilage au lancement de l'outil Instruments.
Appuyez sur le bouton "Démarrer".
Appuyez sur le bouton "Arrêter".
Cliquez sur "os_signpost" pour développer les éléments du sous-système OS Logging.
Cliquez sur le sous-système de journalisation de l'OS "org.tensorflow.lite".
Examinez le résultat de la trace.
Dans cet exemple, vous pouvez afficher la hiérarchie des événements et des statistiques pour chaque heure de l'opérateur.
Utiliser les données de traçage
Les données de traçage vous permettent d'identifier les goulots d'étranglement qui affectent les performances.
Voici quelques exemples d'insights que vous pouvez obtenir du profileur et de solutions potentielles pour améliorer les performances:
- Si le nombre de cœurs de processeur disponibles est inférieur au nombre de threads d'inférence, la surcharge de la planification du processeur peut nuire aux performances. Vous pouvez reprogrammer d'autres tâches nécessitant une utilisation intensive du processeur dans votre application pour éviter tout chevauchement avec l'inférence de votre modèle ou modifier le nombre de threads d'interpréteur.
- Si les opérateurs ne sont pas entièrement délégués, certaines parties du graphe de modèle sont exécutées sur le processeur plutôt que sur l'accélérateur matériel attendu. Vous pouvez remplacer les opérateurs non compatibles par des opérateurs compatibles similaires.