Medición del rendimiento

Herramientas de comparación

Las herramientas comparativas de LiteRT actualmente miden y calculan estadísticas de las siguientes métricas de rendimiento importantes:

• Hora de inicialización
• Tiempo de inferencia del estado de preparación
• Tiempo de inferencia del estado estable
• Uso de memoria durante el tiempo de inicialización
• Uso de memoria general

Las herramientas de comparativas están disponibles como apps de comparativas para iOS y Android, y binarios nativos de la línea de comandos, y todos comparten el mismo rendimiento de medición optimizada. Ten en cuenta que las opciones y los formatos de salida disponibles son un poco diferente debido a las diferencias en el entorno de ejecución.

App comparativa de Android

Existen dos maneras de usar la herramienta de comparativas con Android. Uno es un objeto binario nativo de referencia y otro es un objeto una app comparativa, un mejor indicador del rendimiento del modelo en la app. Cualquiera de las siguientes opciones las cifras de la herramienta de comparativas serán diferentes de cuando ejecutar inferencias con el modelo en la app real.

Esta app comparativa de Android no tiene IU. Instálalo y ejecútalo con adb. y recupera los resultados con el comando adb logcat.

Cómo descargar o compilar la app

Usa los vínculos que aparecen a continuación para descargar las apps de comparativas de Android compiladas previamente para cada noche:

• android_aarch64
• android_arm

En cuanto a las apps comparativas de Android que admiten operaciones de TF a través del delegado de Flex, utiliza los siguientes vínculos:

• android_aarch64
• android_arm

También puedes compilar la app desde el código fuente siguiendo estos pasos: instrucciones.

Prepara las comparativas

Antes de ejecutar la app comparativa, instálala y envía el archivo del modelo al dispositivo de la siguiente manera:

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

Ejecutar comparativas

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

graph es un parámetro obligatorio.

• graph:
  string La ruta de acceso al archivo de modelo de TFLite.

Puedes especificar más parámetros opcionales para ejecutar las comparativas.

• num_threads: int (configuración predeterminada=1)
  Es la cantidad de subprocesos que se usarán para ejecutar el intérprete de TFLite.
• use_gpu: bool (predeterminado=false)
  Usa el delegado de GPU.
• use_xnnpack: bool (valor predeterminado=false)
  Usa Delegado de XNNPACK.

Según el dispositivo que utilices, es posible que algunas de estas opciones no se muestren están disponibles o no tienen efecto. Consulta parámetros para obtener más parámetros de rendimiento que podrías ejecutar con la app comparativa.

Observa los resultados con el comando logcat:

adb logcat | grep "Inference timings"

Los resultados de las comparativas se informan de la siguiente manera:

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

Objeto binario de comparativa nativa

La herramienta de comparativas también se proporciona como un objeto benchmark_model binario nativo. Puedes ejecutar esta herramienta desde una línea de comandos shell en Linux, Mac, dispositivos incorporados y Dispositivos Android

Descarga o compila el objeto binario

Descarga los binarios precompilados nocturnos de la línea de comandos nativos siguiendo el vínculos a continuación:

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

En cuanto a los objetos binarios compilados previamente que admiten TF ops a través del delegado de Flex, utiliza los siguientes vínculos:

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

También puedes compilar el objeto binario de referencia nativo a partir del fuente en tu computadora.

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

Para compilar con la cadena de herramientas del NDK de Android, debes configurar el entorno de compilación. primero siguiendo guía o usa a la imagen de Docker, como se describe guía.

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

Ejecutar comparativas

Para ejecutar comparativas en tu computadora, ejecuta el objeto binario desde la shell.

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

Puedes usar el mismo conjunto de parámetros como se mencionó antes con el objeto binario de línea de comandos nativo.

Creación de perfiles de ops del modelo

El objeto binario del modelo de comparativas también te permite generar perfiles de las operaciones del modelo y obtener la de ejecución de cada operador. Para hacer esto, pasa la marca --enable_op_profiling=true a benchmark_model durante la invocación. Los detalles son explicado aquí.

Objeto binario comparativo nativo para varias opciones de rendimiento en una sola ejecución

También se proporciona un objeto binario C++ conveniente y simple para para comparar varias opciones de rendimiento en una sola ejecución. Este objeto binario se compila según la herramienta de comparativas mencionada anteriormente que solo podía comparar una opción de rendimiento a la vez. Comparten el mismo proceso de compilación/instalación/ejecución, pero el nombre de destino BUILD de este objeto binario es benchmark_model_performance_options y requiere algunos parámetros adicionales. Un parámetro importante para este objeto binario es el siguiente:

perf_options_list: string (default='all')
Una lista separada por comas de opciones de rendimiento de TFLite para comparar.

Puedes obtener objetos binarios compilados previamente para esta herramienta como se indica a continuación:

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

App comparativa para iOS

Para ejecutar comparativas en dispositivos iOS, debes compilar la app a partir de fuente. Coloca el archivo del modelo LiteRT en benchmark_data del árbol de fuentes y modifica el archivo benchmark_params.json. Los que los archivos se empaquetan en la app, y esta lee los datos del directorio. Visitar el App comparativa para iOS para obtener instrucciones detalladas.

Comparativas de rendimiento para modelos conocidos

En esta sección, se enumeran las comparativas de rendimiento de LiteRT cuando se ejecuta bien conocidos en algunos dispositivos iOS y Android.

Comparativas de rendimiento de Android

Estas cifras de comparativas de rendimiento se generaron con el Objeto binario de comparativa nativa.

En el caso de las comparativas de Android, la afinidad de CPU se establece para usar núcleos grandes en el dispositivo. para reducir la varianza (consulta detalles).

Se supone que los modelos se descargaron y descomprimieron en el /data/local/tmp/tflite_models. El objeto binario comparativo se compila estas instrucciones y se supone que están en el directorio /data/local/tmp.

Para ejecutar las comparativas, haz lo siguiente:

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

Para ejecutar con el delegado de la GPU, configura --use_gpu=true.

Los valores de rendimiento que aparecen a continuación se miden en Android 10.

Comparativas de rendimiento de iOS

Estas cifras de comparativas de rendimiento se generaron con el App comparativa para iOS.

Para ejecutar comparativas de iOS, se modificó la app de comparativas a fin de incluir los modelo, y benchmark_params.json se modificó para establecer num_threads en 2. Para usar el delegado de GPU, las opciones "use_gpu" : "1" y "gpu_wait_type" : "aggressive" también se agregaron a benchmark_params.json.

Componentes internos de Trace LiteRT

Componentes internos de Trace LiteRT en Android

Los eventos internos del intérprete LiteRT de una app para Android se pueden capturada por Herramientas de registro de Android. Son los mismos eventos en Android Trace, por lo que Los eventos capturados del código Java o Kotlin se ven juntos con LiteRT. eventos internos.

Estos son algunos ejemplos de eventos:

• Invocación del operador
• Modificación de grafos por delegado
• Asignación de tensores

Entre las diferentes opciones para capturar registros, en esta guía se abordan las bibliotecas el Generador de perfiles de CPU de Studio y la app de Registro del sistema. Consulta La herramienta de línea de comandos de Perfetto o Herramienta de línea de comandos Systrace para otras opciones.

Agrega eventos de seguimiento en código Java

Este es un fragmento de código del Clasificación de imágenes app de ejemplo. El intérprete de LiteRT se ejecuta Sección recognizeImage/runInference. Este paso es opcional, pero es útil para para detectar dónde se hace la llamada de inferencia.

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

Cómo habilitar el seguimiento de LiteRT

Para habilitar el seguimiento de LiteRT, configura la propiedad del sistema Android debug.tflite.trace en 1 antes de iniciar la app para Android.

adb shell setprop debug.tflite.trace 1

Si se configuró esta propiedad cuando se inicializa el intérprete de LiteRT, los eventos clave (p.ej., la invocación del operador) del intérprete.

Después de capturar todos los seguimientos, configura el valor de la propiedad para inhabilitar el seguimiento en 0.

adb shell setprop debug.tflite.trace 0

Generador de perfiles de CPU de Android Studio

Captura registros con el Generador de perfiles de CPU de Android Studio siguiendo estos pasos:

1. Selecciona Ejecutar > Perfil “app” en los menús superiores.

2. Haz clic en cualquier lugar del cronograma de la CPU cuando aparezca la ventana de Profiler.

3. Selecciona "Trace System Clicks" (Llamadas del sistema de seguimiento). entre los modos de creación de perfiles de CPU.

   

4. Presiona "Grabar". .

5. Presiona "Detener". .

6. Investiga el resultado del seguimiento.

   

En este ejemplo, puedes ver la jerarquía de eventos en un subproceso y las estadísticas para cada tiempo del operador y también ver el flujo de datos de toda la app entre conversaciones.

La app de Registro del sistema

Para capturar registros sin Android Studio, sigue los pasos que se detallan en App de Registro del sistema.

En este ejemplo, se capturaron los mismos eventos de TFLite y se guardaron en Perfetto. o Systrace según la versión del dispositivo Android. La captura los archivos de registro se pueden abrir en la IU de Perfetto.

Componentes internos de Trace LiteRT en iOS

Los eventos internos del intérprete LiteRT de una aplicación para iOS se pueden capturada por Instrumentos con Xcode. Son los sistemas de administración signpost eventos, de modo que los eventos capturados del código Swift/Objective-C se vean juntos con eventos internos LiteRT.

Estos son algunos ejemplos de eventos:

• Invocación del operador
• Modificación de grafos por delegado
• Asignación de tensores

Cómo habilitar el seguimiento de LiteRT

Configura la variable de entorno debug.tflite.trace con los siguientes pasos:

1. Selecciona Producto > Esquema > Edit Scheme... en los menús superiores de Xcode.

2. Haz clic en "Perfil". en el panel izquierdo.

3. Anula la selección de “Usa los argumentos y las variables de entorno de la acción Run” .

4. Agrega debug.tflite.trace en “Variables de entorno”. sección.

   

Si quieres excluir eventos LiteRT cuando generes perfiles de la app para iOS, sigue estos pasos: inhabilitar el seguimiento quitando la variable de entorno.

Instrumentos de Xcode

Para capturar registros, sigue estos pasos:

1. Selecciona Producto > Perfil en los menús superiores de Xcode.

2. Haz clic en Logging entre las plantillas de generación de perfiles cuando se inicie la herramienta Instruments.

3. Presiona "Iniciar". .

4. Presiona "Detener". .

5. Haz clic en 'os_signpost'. expandir los elementos del subsistema de registro del SO.

6. Haz clic en 'org.tensorflow.lite' Subsistema de registros del SO.

7. Investiga el resultado del seguimiento.

   

En este ejemplo, puedes ver la jerarquía de eventos y estadísticas de cada tiempo del operador.

Usa los datos de seguimiento

Los datos de seguimiento te permiten identificar cuellos de botella en el rendimiento.

Estos son algunos ejemplos de información que puedes obtener del generador de perfiles y Soluciones potenciales para mejorar el rendimiento:

• Si la cantidad de núcleos de CPU disponibles es menor que la de inferencia subprocesos, la sobrecarga de programación de la CPU puede generar un rendimiento deficiente. Puedes reprogramar otras tareas con uso intensivo de CPU en tu aplicación para evitar se superpone con la inferencia de tu modelo o ajusta la cantidad de instancias conversaciones.
• Si los operadores no se delegan por completo, algunas partes del grafo del modelo se ejecutan en la CPU y no en el acelerador de hardware esperado. Tú puede sustituir los operadores no admitidos por otros compatibles similares.