Mesure des performances

Outils de référence

Les outils de référence TensorFlow Lite mesurent et calculent actuellement des statistiques pour les mesures de performances importantes suivantes :

• Temps d'initialisation
• Temps d'inférence de l'état d'échauffement
• Temps d'inférence de l'état stationnaire
• Utilisation de la mémoire pendant le temps d'initialisation
• Utilisation globale de la mémoire

Les outils de référence sont disponibles sous forme d'applications de référence pour Android et iOS et sous forme de binaires de ligne de commande natifs, et ils partagent tous la même logique de mesure des performances de base. Notez que les options disponibles et les formats de sortie sont légèrement différents en raison des différences dans l'environnement d'exécution.

Application de référence Android

Il existe deux options pour utiliser l'outil de référence avec Android. L’un est un binaire de référence natif et l’autre est une application de référence Android, une meilleure évaluation des performances du modèle dans l’application. Quoi qu'il en soit, les chiffres de l'outil de référence seront toujours légèrement différents de ceux obtenus lors de l'exécution de l'inférence avec le modèle dans l'application réelle.

Cette application de référence Android n'a pas d'interface utilisateur. Installez-le et exécutez-le à l'aide de la commande adb et récupérez les résultats à l'aide de la commande adb logcat .

Téléchargez ou créez l'application

Téléchargez les applications de référence Android prédéfinies chaque soir à l'aide des liens ci-dessous :

• android_aarch64
• bras_android

En ce qui concerne les applications de référence Android prenant en charge les opérations TF via Flex délégué , utilisez les liens ci-dessous :

• android_aarch64
• bras_android

Vous pouvez également créer l'application à partir des sources en suivant ces instructions .

Préparer le benchmark

Avant d'exécuter l'application de référence, installez l'application et transférez le fichier de modèle sur l'appareil comme suit :

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

Exécuter un benchmark

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph est un paramètre obligatoire.

• graph : string
  Le chemin d'accès au fichier de modèle TFLite.

Vous pouvez spécifier davantage de paramètres facultatifs pour exécuter le benchmark.

• num_threads : int (par défaut = 1)
  Le nombre de threads à utiliser pour exécuter l’interpréteur TFLite.
• use_gpu : bool (par défaut = faux)
  Utiliser un délégué GPU .
• use_nnapi : bool (par défaut = faux)
  Utilisez le délégué NNAPI .
• use_xnnpack : bool (par défaut = false )
  Utilisez le délégué XNNPACK .
• use_hexagon : bool (par défaut= false )
  Utilisez le délégué Hexagon .

Selon l'appareil que vous utilisez, certaines de ces options peuvent ne pas être disponibles ou n'avoir aucun effet. Reportez-vous aux paramètres pour plus de paramètres de performances que vous pouvez exécuter avec l'application de référence.

Affichez les résultats à l'aide de la commande logcat :

adb logcat | grep "Inference timings"

Les résultats de référence 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 référence natif

L'outil de référence est également fourni sous forme de 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échargez ou construisez le binaire

Téléchargez les binaires de ligne de commande natifs prédéfinis chaque soir en suivant les liens ci-dessous :

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• bras_android

En ce qui concerne les binaires prédéfinis nocturnes qui prennent en charge les opérations TF via Flex délégué , utilisez les liens ci-dessous :

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• bras_android

Pour effectuer une comparaison avec le délégué TensorFlow Lite Hexagon , nous avons également pré-construit les fichiers libhexagon_interface.so requis (voir ici pour plus de détails sur ce fichier). Après avoir téléchargé le fichier de la plateforme correspondante à partir des liens ci-dessous, veuillez renommer le fichier en libhexagon_interface.so .

• android_aarch64
• bras_android

Vous pouvez également créer le binaire de référence natif à partir des sources sur votre ordinateur.

bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model

Pour construire avec la chaîne d'outils Android NDK, vous devez d'abord configurer l'environnement de construction 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 un benchmark

Pour exécuter des tests de performance 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.

Profilage des opérations de modèle

Le modèle binaire de référence 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'indicateur --enable_op_profiling=true à benchmark_model lors de l'invocation. Les détails sont expliqués ici .

Binaire de référence natif pour plusieurs options de performances en une seule exécution

Un binaire C++ pratique et simple est également fourni pour évaluer plusieurs options de performances en une seule exécution. Ce binaire est construit sur la base de l'outil de référence susmentionné qui ne peut évaluer qu'une seule option de performance à la fois. Ils partagent le même processus de construction/installation/exécution, mais le nom cible BUILD de ce binaire est benchmark_model_performance_options et il prend quelques paramètres supplémentaires. Un paramètre important pour ce binaire est :

perf_options_list : string (par défaut='all')
Une liste d'options de performances TFLite à comparer, séparées par des virgules.

Vous pouvez obtenir des binaires prédéfinis chaque nuit pour cet outil, comme indiqué ci-dessous :

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• bras_android

Application de référence iOS

Pour exécuter des tests de performance sur un appareil iOS, vous devez créer l'application à partir des sources . Placez le fichier de modèle TensorFlow Lite dans le répertoire benchmark_data de l'arborescence source et modifiez le fichier benchmark_params.json . Ces fichiers sont regroupés dans l'application et celle-ci lit les données du répertoire. Visitez l' application de référence iOS pour obtenir des instructions détaillées.

Benchmarks de performances pour des modèles bien connus

Cette section répertorie les tests de performances de TensorFlow Lite lors de l'exécution de modèles bien connus sur certains appareils Android et iOS.

Tests de performances Android

Ces chiffres de référence de performances ont été générés avec le binaire de référence natif .

Pour les tests Android, l'affinité du processeur est configurée pour utiliser de gros cœurs sur l'appareil afin de réduire la variance (voir les détails ).

Cela suppose 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 référence est construit à l'aide de ces instructions et supposé se trouver dans le répertoire /data/local/tmp .

Pour exécuter le benchmark :

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 le délégué nnapi, définissez --use_nnapi=true . Pour exécuter avec un délégué GPU, définissez --use_gpu=true .

Les valeurs de performances ci-dessous sont mesurées sur Android 10.

Benchmarks de performances iOS

Ces chiffres de référence de performances ont été générés avec l' application de référence iOS .

Pour exécuter des benchmarks iOS, l'application de benchmark a été modifiée pour 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" étaient également ajouté à benchmark_params.json .

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 . Ce sont les mêmes événements avec l'API Android Trace , de sorte que les événements capturés à partir du code Java/Kotlin sont vus avec les événements internes de TensorFlow Lite.

Voici quelques exemples d'événements :

• Invocation de l'opérateur
• Modification du graphique par délégué
• Allocation de tenseur

Parmi les différentes options de capture de traces, ce guide couvre le profileur de processeur Android Studio et l'application System Tracing. Reportez-vous à l'outil de ligne de commande Perfetto ou à l'outil de ligne de commande Systrace pour d'autres options.

Ajout d'événements de trace dans le code Java

Il s'agit d'un extrait de code de l'exemple d'application Image Classification . L'interpréteur TensorFlow Lite s'exécute dans la section recognizeImage/runInference . Cette étape est facultative mais elle est utile pour déterminer où l'appel d'inférence est effectué.

  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 (par exemple, l'invocation de l'opérateur) 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

Capturez des traces avec Android Studio CPU Profiler en suivant les étapes ci-dessous :

1. Sélectionnez Exécuter > Profil « application » dans les menus supérieurs.

2. Cliquez n'importe où dans la chronologie du processeur lorsque la fenêtre du profileur apparaît.

3. Sélectionnez « Tracer les appels système » parmi les modes de profilage du processeur.

   

4. Appuyez sur le bouton « Enregistrer ».

5. Appuyez sur le bouton « Arrêter ».

6. 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 d'opérateur, ainsi que le flux de données de l'ensemble de l'application entre les threads.

Application de traçage du système

Capturez des traces sans Android Studio en suivant les étapes détaillées dans l'application System Tracing .

Dans cet exemple, les mêmes événements TFLite ont été capturés et enregistrés au format Perfetto ou Systrace selon la version de l'appareil Android. Les fichiers de trace capturés peuvent être ouverts dans l' interface utilisateur 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 de signalisation iOS, de sorte que 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 :

• Invocation de l'opérateur
• Modification du graphique par délégué
• Allocation de tenseur

Activer le traçage TensorFlow Lite

Définissez la variable d'environnement debug.tflite.trace en suivant les étapes ci-dessous :

1. Sélectionnez Produit > Schéma > Modifier le schéma... dans les menus supérieurs de Xcode.

2. Cliquez sur « Profil » dans le volet de gauche.

3. Décochez la case « Utiliser les arguments et les variables d'environnement de l'action Exécuter ».

4. Ajoutez debug.tflite.trace dans 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

Capturez des traces en suivant les étapes ci-dessous :

1. Sélectionnez Produit > Profil dans les menus supérieurs de Xcode.

2. Cliquez sur Journalisation parmi les modèles de profilage lorsque l'outil Instruments est lancé.

3. Appuyez sur le bouton « Démarrer ».

4. Appuyez sur le bouton « Arrêter ».

5. Cliquez sur « os_signpost » pour développer les éléments du sous-système OS Logging.

6. Cliquez sur le sous-système de journalisation du système d'exploitation « org.tensorflow.lite ».

7. Examinez le résultat de la trace.

   

Dans cet exemple, vous pouvez voir la hiérarchie des événements et des statistiques pour chaque heure d'opérateur.

Utilisation des données de traçage

Les données de traçage vous permettent d'identifier les goulots d'étranglement en matière de performances.

Voici quelques exemples d’informations 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 planification du processeur peut entraîner des performances inférieures à la moyenne. Vous pouvez replanifier d'autres tâches gourmandes en CPU dans votre application pour éviter tout chevauchement avec l'inférence de votre modèle ou modifier le nombre de threads d'interprétation.
• Si les opérateurs ne sont pas entièrement délégués, certaines parties du graphe du 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 pris en charge par des opérateurs similaires pris en charge.