Medición del desempeño

Herramientas de referencia

Las herramientas de referencia de TensorFlow Lite actualmente miden y calculan estadísticas para las siguientes métricas de rendimiento importantes:

  • Tiempo de inicialización
  • Tiempo de inferencia del estado de calentamiento.
  • Tiempo de inferencia del estado estacionario.
  • Uso de memoria durante el tiempo de inicialización
  • Uso general de la memoria

Las herramientas de referencia están disponibles como aplicaciones de referencia para Android e iOS y como archivos binarios de línea de comandos nativos, y todas comparten la misma lógica central de medición del rendimiento. Tenga en cuenta que las opciones disponibles y los formatos de salida son ligeramente diferentes debido a las diferencias en el entorno de ejecución.

Aplicación de referencia de Android

Hay dos opciones para utilizar la herramienta de referencia con Android. Uno es un binario de referencia nativo y otro es una aplicación de referencia de Android, un mejor indicador de cómo se comportaría el modelo en la aplicación. De cualquier manera, los números de la herramienta de referencia seguirán siendo ligeramente diferentes de los de cuando se ejecuta la inferencia con el modelo en la aplicación real.

Esta aplicación de referencia de Android no tiene interfaz de usuario. Instálelo y ejecútelo usando el comando adb y recupere los resultados usando el comando adb logcat .

Descargue o cree la aplicación

Descargue las aplicaciones de referencia nocturnas de Android prediseñadas utilizando los enlaces a continuación:

En cuanto a las aplicaciones de referencia de Android que admiten operaciones TF a través del delegado Flex , utilice los enlaces a continuación:

También puedes crear la aplicación desde el código fuente siguiendo estas instrucciones .

Preparar punto de referencia

Antes de ejecutar la aplicación de referencia, instálela y envíe 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 punto de referencia

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 al archivo del modelo TFLite.

Puede especificar más parámetros opcionales para ejecutar el punto de referencia.

  • num_threads : int (predeterminado = 1)
    La cantidad de subprocesos que se utilizarán para ejecutar el intérprete TFLite.
  • use_gpu : bool (predeterminado = falso)
    Utilice delegado de GPU .
  • use_nnapi : bool (predeterminado = falso)
    Utilice el delegado NNAPI .
  • use_xnnpack : bool (predeterminado = false )
    Utilice el delegado XNNPACK .
  • use_hexagon : bool (predeterminado = false )
    Utilice el delegado hexagonal .

Dependiendo del dispositivo que esté utilizando, es posible que algunas de estas opciones no estén disponibles o no tengan ningún efecto. Consulte los parámetros para obtener más parámetros de rendimiento que podría ejecutar con la aplicación de referencia.

Vea los resultados usando el comando logcat :

adb logcat | grep "Inference timings"

Los resultados de referencia se informan como:

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

Binario de referencia nativo

La herramienta de referencia también se proporciona como un benchmark_model binario nativo. Puede ejecutar esta herramienta desde una línea de comando de shell en Linux, Mac, dispositivos integrados y dispositivos Android.

Descargue o cree el binario

Descargue los binarios de línea de comandos nativos prediseñados todas las noches siguiendo los enlaces siguientes:

En cuanto a los binarios prediseñados nocturnos que admiten operaciones TF a través del delegado Flex , utilice los enlaces a continuación:

Para realizar pruebas comparativas con el delegado de TensorFlow Lite Hexagon , también hemos creado previamente los archivos libhexagon_interface.so necesarios (consulte aquí para obtener detalles sobre este archivo). Después de descargar el archivo de la plataforma correspondiente desde los enlaces siguientes, cambie el nombre del archivo a libhexagon_interface.so .

También puede crear el binario de referencia nativo desde el código fuente en su computadora.

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

Para compilar con la cadena de herramientas NDK de Android, primero debe configurar el entorno de compilación siguiendo esta guía o usar la imagen de la ventana acoplable como se describe en esta guía .

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

Ejecutar punto de referencia

Para ejecutar puntos de referencia en su computadora, ejecute el binario desde el shell.

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

Puede utilizar el mismo conjunto de parámetros mencionado anteriormente con el binario de línea de comandos nativo.

Operaciones de modelo de elaboración de perfiles

El modelo binario de referencia también le permite perfilar las operaciones del modelo y obtener los tiempos de ejecución de cada operador. Para hacer esto, pase la bandera --enable_op_profiling=true a benchmark_model durante la invocación. Los detalles se explican aquí .

Binario de referencia nativo para múltiples opciones de rendimiento en una sola ejecución

También se proporciona un binario C++ conveniente y simple para comparar múltiples opciones de rendimiento en una sola ejecución. Este binario está construido en base a la herramienta de referencia antes mencionada que solo puede comparar una única opción de rendimiento a la vez. Comparten el mismo proceso de compilación/instalación/ejecución, pero el nombre de destino de CONSTRUCCIÓN de este binario es benchmark_model_performance_options y requiere algunos parámetros adicionales. Un parámetro importante para este binario es:

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

Puede obtener archivos binarios prediseñados todas las noches para esta herramienta como se detalla a continuación:

aplicación de referencia de iOS

Para ejecutar pruebas comparativas en un dispositivo iOS, debe crear la aplicación desde el código fuente . Coloque el archivo de modelo de TensorFlow Lite en el directorio benchmark_data del árbol de origen y modifique el archivo benchmark_params.json . Esos archivos se empaquetan en la aplicación y la aplicación lee datos del directorio. Visite la aplicación de referencia de iOS para obtener instrucciones detalladas.

Puntos de referencia de rendimiento para modelos conocidos

Esta sección enumera los puntos de referencia de rendimiento de TensorFlow Lite cuando se ejecutan modelos conocidos en algunos dispositivos Android e iOS.

Puntos de referencia de rendimiento de Android

Estos números de referencia de rendimiento se generaron con el binario de referencia nativo .

Para las pruebas comparativas de Android, la afinidad de la CPU está configurada para utilizar núcleos grandes en el dispositivo para reducir la variación (consulte los detalles ).

Se supone que los modelos se descargaron y descomprimieron en el directorio /data/local/tmp/tflite_models . El binario de referencia se construye usando estas instrucciones y se supone que está en el directorio /data/local/tmp .

Para ejecutar el punto de referencia:

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 nnapi, configure --use_nnapi=true . Para ejecutar con delegado de GPU, configure --use_gpu=true .

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

Nombre del modelo Dispositivo CPU, 4 hilos GPU NNAPI
Mobilenet_1.0_224(flotante) Píxel 3 23,9 ms 6,45 ms 13,8 ms
Píxel 4 14,0 ms 9,0 ms 14,8 ms
Mobilenet_1.0_224 (cuantitativo) Píxel 3 13,4 ms --- 6,0 ms
Píxel 4 5,0 ms --- 3,2 ms
NASNet móvil Píxel 3 56 ms --- 102 ms
Píxel 4 34,5 ms --- 99,0 ms
ApretarNet Píxel 3 35,8 ms 9,5 ms 18,5 ms
Píxel 4 23,9 ms 11,1 ms 19,0 ms
Inicio_ResNet_V2 Píxel 3 422 ms 99,8 ms 201 ms
Píxel 4 272,6 ms 87,2 ms 171,1 ms
Inicio_V4 Píxel 3 486 ms 93 ms 292 ms
Píxel 4 324,1 ms 97,6 ms 186,9 ms

Puntos de referencia de rendimiento de iOS

Estos números de referencia de rendimiento se generaron con la aplicación de referencia de iOS .

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

Nombre del modelo Dispositivo CPU, 2 hilos GPU
Mobilenet_1.0_224(flotante) iPhone XS 14,8 ms 3,4 ms
Mobilenet_1.0_224 (cuantitativo) iPhone XS 11 ms ---
NASNet móvil iPhone XS 30,4 ms ---
ApretarNet iPhone XS 21,1 ms 15,5 ms
Inicio_ResNet_V2 iPhone XS 261,1 ms 45,7 ms
Inicio_V4 iPhone XS 309 ms 54,4 ms

Seguimiento de los componentes internos de TensorFlow Lite

Seguimiento de los componentes internos de TensorFlow Lite en Android

Las herramientas de seguimiento de Android pueden capturar eventos internos del intérprete de TensorFlow Lite de una aplicación de Android. Son los mismos eventos con Android Trace API, por lo que los eventos capturados del código Java/Kotlin se ven junto con los eventos internos de TensorFlow Lite.

Algunos ejemplos de eventos son:

  • Invocación del operador
  • Modificación de gráfico por delegado.
  • Asignación de tensor

Entre las diferentes opciones para capturar seguimientos, esta guía cubre Android Studio CPU Profiler y la aplicación System Tracing. Consulte la herramienta de línea de comandos Perfetto o la herramienta de línea de comandos Systrace para conocer otras opciones.

Agregar eventos de seguimiento en código Java

Este es un fragmento de código de la aplicación de ejemplo de Clasificación de imágenes . El intérprete de TensorFlow Lite se ejecuta en la sección recognizeImage/runInference . Este paso es opcional pero es útil para ayudar a notar dónde se realiza 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();

Habilitar el seguimiento de TensorFlow Lite

Para habilitar el seguimiento de TensorFlow Lite, establezca la propiedad del sistema Android debug.tflite.trace en 1 antes de iniciar la aplicación de Android.

adb shell setprop debug.tflite.trace 1

Si esta propiedad se estableció cuando se inicializa el intérprete de TensorFlow Lite, se rastrearán los eventos clave (por ejemplo, la invocación del operador) del intérprete.

Después de capturar todos los seguimientos, deshabilite el seguimiento estableciendo el valor de la propiedad en 0.

adb shell setprop debug.tflite.trace 0

Perfilador de CPU de Android Studio

Capture seguimientos con Android Studio CPU Profiler siguiendo los pasos a continuación:

  1. Seleccione Ejecutar > Perfil de 'aplicación' en los menús superiores.

  2. Haga clic en cualquier lugar de la línea de tiempo de la CPU cuando aparezca la ventana del Generador de perfiles.

  3. Seleccione 'Seguimiento de llamadas al sistema' entre los modos de creación de perfiles de CPU.

    Seleccione 'Rastrear llamadas al sistema'

  4. Presione el botón 'Grabar'.

  5. Presione el botón 'Detener'.

  6. Investigue el resultado del rastreo.

    Seguimiento de Android Studio

En este ejemplo, puede ver la jerarquía de eventos en un subproceso y estadísticas para el tiempo de cada operador y también ver el flujo de datos de toda la aplicación entre subprocesos.

Aplicación de seguimiento del sistema

Capture seguimientos sin Android Studio siguiendo los pasos detallados en la aplicación System Tracing .

En este ejemplo, los mismos eventos TFLite se capturaron y guardaron en formato Perfetto o Systrace según la versión del dispositivo Android. Los archivos de seguimiento capturados se pueden abrir en la interfaz de usuario de Perfetto .

rastro perfecto

Seguimiento de los componentes internos de TensorFlow Lite en iOS

Los eventos internos del intérprete de TensorFlow Lite de una aplicación de iOS se pueden capturar mediante la herramienta Instruments incluida con Xcode. Son los eventos de señalización de iOS, por lo que los eventos capturados del código Swift/Objective-C se ven junto con los eventos internos de TensorFlow Lite.

Algunos ejemplos de eventos son:

  • Invocación del operador
  • Modificación de gráfico por delegado.
  • Asignación de tensor

Habilitar el seguimiento de TensorFlow Lite

Configure la variable de entorno debug.tflite.trace siguiendo los pasos a continuación:

  1. Seleccione Producto > Esquema > Editar esquema... en los menús superiores de Xcode.

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

  3. Deseleccione la casilla de verificación 'Usar los argumentos y las variables de entorno de la acción Ejecutar'.

  4. Agregue debug.tflite.trace en la sección 'Variables de entorno'.

    Establecer variable de entorno

Si desea excluir eventos de TensorFlow Lite al crear perfiles de la aplicación iOS, deshabilite el seguimiento eliminando la variable de entorno.

Instrumentos XCode

Capture rastros siguiendo los pasos a continuación:

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

  2. Haga clic en Registro entre las plantillas de creación de perfiles cuando se inicie la herramienta Instrumentos.

  3. Presiona el botón de inicio.

  4. Presione el botón 'Detener'.

  5. Haga clic en 'os_signpost' para expandir los elementos del subsistema de registro del sistema operativo.

  6. Haga clic en el subsistema de registro del sistema operativo 'org.tensorflow.lite'.

  7. Investigue el resultado del rastreo.

    Seguimiento de instrumentos Xcode

En este ejemplo, puede ver la jerarquía de eventos y estadísticas para el tiempo de cada operador.

Usando los datos de rastreo

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

A continuación, se muestran algunos ejemplos de información que puede obtener del generador de perfiles y posibles soluciones para mejorar el rendimiento:

  • Si la cantidad de núcleos de CPU disponibles es menor que la cantidad de subprocesos de inferencia, entonces la sobrecarga de programación de la CPU puede generar un rendimiento deficiente. Puede reprogramar otras tareas intensivas de CPU en su aplicación para evitar superposiciones con la inferencia de su modelo o modificar la cantidad de subprocesos del intérprete.
  • Si los operadores no están completamente delegados, algunas partes del gráfico del modelo se ejecutan en la CPU en lugar del acelerador de hardware esperado. Puede sustituir los operadores no admitidos por operadores compatibles similares.