Mesure des performances

Outils d'analyse comparative

Actuellement, les outils de benchmark LiteRT mesurent et calculent des statistiques pour les métriques de performances importantes suivantes:

• Délai d'initialisation
• Durée d'inférence de l'état de préchauffage
• Heure d'inférence de l'état stable
• Utilisation de la mémoire pendant l'initialisation
• Utilisation globale de la mémoire

Ces outils sont disponibles en tant qu'applications d'analyse comparative pour Android et iOS, binaires de ligne de commande natifs et partagent les mêmes performances logique de mesure. Notez que les options et les formats de sortie disponibles légèrement différent en raison des différences dans l'environnement d'exécution.

Application de benchmark Android

Deux options s'offrent à vous pour utiliser l'outil d'analyse comparative avec Android. L'un est un le binaire de benchmark natif et un autre est une application de référence, une meilleure évaluation des performances du modèle dans l'application. L'un ou l'autre les chiffres obtenus avec l'outil d'analyse comparative diffèrent légèrement exécuter une inférence avec le modèle dans l'application réelle.

Cette application de benchmark Android n'a pas d'interface utilisateur. Installez-le et exécutez-le à l'aide de adb. et 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 chaque nuit à l'aide des liens ci-dessous:

• android_aarch64
• android_arm

En ce qui concerne les applications d'analyse comparative Android compatibles avec TF Ops via un délégué Flex, cliquez sur les liens ci-dessous:

• android_aarch64
• android_arm

Vous pouvez également créer l'application à partir de la source en suivant ces instructions.

Préparer le benchmark

Avant d'exécuter l'analyse comparative, installez l'application et transférez le fichier de modèle vers 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"'

Le paramètre graph est obligatoire.

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

Vous pouvez spécifier d'autres paramètres facultatifs pour l'exécution de 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=false)
  Utilisez Délégué de GPU.
• use_xnnpack: bool (par défaut=false)
  Utilisez Délégué XNNPACK.

Selon l'appareil que vous utilisez, il est possible que certaines de ces options ne soient pas disponibles ou n'ont aucun effet. Consultez paramètres pour découvrir d'autres paramètres de performances que vous pouvez exécuter avec l'application d'analyse comparative.

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

adb logcat | grep "Inference timings"

Les résultats du benchmark sont indiqués comme suit:

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

Binaire du benchmark natif

L'outil d'analyse comparative est également fourni en tant que fichier binaire natif benchmark_model. Vous pouvez exécuter cet outil à partir d'une ligne de commande shell sur Linux, Mac, les périphériques intégrés et Appareils Android

Télécharger ou compiler le binaire

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

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Comme pour les binaires prédéfinis qui prennent en charge TF ops via un délégué Flex, cliquez sur les liens ci-dessous:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Vous pouvez également créer le binaire du benchmark natif à partir de source sur votre ordinateur.

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

Pour compiler avec la chaîne d'outils NDK Android, vous devez configurer l'environnement de compilation en suivant cette guide, ou utilisez l'image Docker, comme décrit dans cette .

bazel build -c opt --config=android_arm64 \
  //tensorflow/lite/tools/benchmark:benchmark_model

Exécuter un benchmark

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 paramètres comme indiqué 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 de modèle et d'obtenir les temps d'exécution de chaque opérateur. Pour ce faire, transmettez l'indicateur --enable_op_profiling=true sur benchmark_model pendant l'appel. Les détails sont expliqué cliquez ici.

Binaire natif du benchmark pour plusieurs options de performances en une seule exécution

Un binaire C++ simple et pratique est également fourni pour comparer plusieurs options de performances en une seule exécution. Ce binaire est basé sur l'outil de benchmark mentionné précédemment qui ne pouvait comparer qu'une seule option de performances à la fois. Ils partagent le le même processus de compilation, d'installation et d'exécution, mais le nom cible de la compilation de ce binaire est benchmark_model_performance_options et accepte 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 des binaires prédéfinis chaque nuit pour cet outil, comme indiqué ci-dessous:

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

Application benchmark iOS

Pour exécuter des analyses comparatives sur un appareil iOS, vous devez créer l'application à partir de source. Placez le fichier de modèle LiteRT dans benchmark_data répertoire de l'arborescence source et modifiez le fichier benchmark_params.json. Ces fichiers sont empaquetés dans l'application et celle-ci lit les données du répertoire. Rendez-vous sur la Application benchmark iOS pour obtenir des instructions détaillées.

Benchmarks de performances pour des modèles connus

Cette section liste les benchmarks de performances LiteRT si l'exécution fonctionne correctement sur certains appareils Android et iOS.

Benchmarks des performances Android

Ces chiffres du benchmark des performances ont été générés à l'aide du binaire de benchmark natif.

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

Nous supposons ici que les modèles ont été téléchargés et décompressés dans Répertoire /data/local/tmp/tflite_models. Le binaire de benchmark est construit à l'aide de ces instructions et est censé 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 l'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.

Analyses comparatives des performances iOS

Ces chiffres du benchmark des performances ont été générés à l'aide du Application comparative iOS :

Pour exécuter les analyses comparatives iOS, l'application correspondante a été modifiée afin d'inclure les model et benchmark_params.json a été modifié pour définir num_threads sur 2. Pour utiliser le délégué de GPU, ainsi que les options "use_gpu" : "1" et "gpu_wait_type" : "aggressive". ont également été ajoutées à benchmark_params.json.

Éléments internes Trace LiteRT

Trace les éléments internes LiteRT dans Android

Les événements internes de l'interpréteur LiteRT d'une application Android peuvent être capturé par Outils de traçage Android Il s'agit des mêmes événements avec Android Trace : Les événements capturés à partir du code Java/Kotlin s'affichent avec LiteRT. les événements internes.

Voici quelques exemples d'événements:

• Appel de l'opérateur
• Modification du graphique par délégué
• Allocation de Tensors

Ce guide présente, entre autres, les options de capture de traces Profileur de processeur Studio et application de traçage système. Consultez Outil de ligne de commande Perfetto ou Outil de ligne de commande Systrace pour découvrir d'autres options.

Ajouter des événements de trace en code Java

Il s'agit d'un extrait de code Classification d'images exemple d'application. L'interpréteur LiteRT s'exécute recognizeImage/runInference. Cette étape est facultative, mais elle est utile pour permet de repérer 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 LiteRT

Pour activer le traçage LiteRT, définissez la propriété système Android debug.tflite.trace sur 1 avant de lancer 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 LiteRT, les événements clés (appels d'opérateurs, etc.) de l'interpréteur seront suivis.

Après avoir capturé toutes les traces, désactivez le traçage en définissant la valeur de la propriété à 0.

adb shell setprop debug.tflite.trace 0

Profileur de processeur Android Studio

Capturer les traces avec Profileur de processeur Android Studio en procédant comme suit:

1. Sélectionnez Exécuter > Profilez "app" dans les menus supérieurs.

2. Cliquez n'importe où dans la chronologie du processeur lorsque la fenêtre de Profiler s'affiche.

3. Sélectionnez "Trace System Calls" (Tracer les appels système). entre les modes de profilage du processeur.

   

4. Appuyez sur "Enregistrer". .

5. Appuyez sur "Stop" (Arrêter). .

6. Examinez le résultat de la trace.

   

Dans cet exemple, vous pouvez voir la hiérarchie des événements dans un fil de discussion et les statistiques. pour chaque heure d'opérateur et afficher 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 Application de traçage système.

Dans cet exemple, les mêmes événements TFLite ont été capturés et enregistrés dans le répertoire Perfetto. ou Systrace, selon la version de l'appareil Android. L'entité capturée les fichiers de suivi peuvent être ouverts dans l'interface utilisateur de Perfetto.

Trace LiteRT interne dans iOS

Les événements internes de l'interpréteur LiteRT d'une application iOS peuvent être capturé par Instruments fourni avec Xcode. Il s'agit des applications iOS signpost événements, afin que les événements capturés à partir du code Swift/Objective-C soient vus ensemble avec les événements internes LiteRT.

Voici quelques exemples d'événements:

• Appel de l'opérateur
• Modification du graphique par délégué
• Allocation de Tensors

Activer le traçage LiteRT

Définissez la variable d'environnement debug.tflite.trace en procédant comme suit:

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ésélectionnez "Utiliser les arguments et les variables d'environnement de l'action d'exécution". .

4. Ajoutez debug.tflite.trace sous "Variables d'environnement". .

   

Si vous souhaitez exclure les événements LiteRT lors du profilage de l'application iOS, désactiver le traçage en supprimant la variable d'environnement.

Instruments XCode

Pour capturer des traces, procédez comme suit:

1. Sélectionnez Produit > Profile dans le menu supérieur de Xcode.

2. Cliquez sur Logging (Journalisation) parmi les modèles de profilage au lancement de l'outil "Instruments".

3. Appuyez sur "Démarrer". .

4. Appuyez sur "Stop" (Arrêter). .

5. Cliquez sur "os_signpost". pour développer les éléments du sous-système de journalisation du système d'exploitation.

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

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 à l'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'informations que vous pouvez obtenir grâce au profileur des solutions potentielles pour améliorer les performances:

• Si le nombre de cœurs de processeur disponibles est inférieur au nombre d'inférences la surcharge du processeur peut entraîner des performances médiocres. Vous pouvez replanifier d'autres tâches nécessitant une utilisation intensive des processeurs dans votre application qui chevauche l'inférence de votre modèle ou l'ajustement du nombre d'interpréteurs les threads.
• Si les opérateurs ne sont pas entièrement délégués, certaines parties du graphe du modèle sont exécutés sur le CPU plutôt que sur l'accélérateur matériel attendu. Toi peut remplacer les opérateurs non pris en charge par des opérateurs compatibles similaires.