Se usó la API de Cloud Translation para traducir esta página.
Switch to English

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 estable
  • Uso de memoria durante el tiempo de inicialización
  • Uso de memoria general

Las herramientas de referencia están disponibles como aplicaciones de referencia para Android e iOS y como binarios nativos de línea de comandos, y todas comparten la misma lógica de medición de rendimiento central. 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 usar 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 funcionaría el modelo en la aplicación. De cualquier manera, los números de la herramienta de referencia seguirán siendo ligeramente diferentes 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 con el comando adb y recupere los resultados con el comando adb logcat .

Descarga o crea la aplicación

Descargue las aplicaciones de referencia de Android predefinidas nocturnas utilizando los enlaces a continuación:

También puede crear la aplicación desde la fuente siguiendo estas instrucciones .

Preparar punto de referencia

Antes de ejecutar la aplicación de referencia, instale la aplicación 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 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 es un parámetro obligatorio.

  • graph : string
    La ruta al archivo del modelo TFLite.

Puede especificar más parámetros opcionales para ejecutar la prueba comparativa.

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

Según el dispositivo que esté utilizando, es posible que algunas de estas opciones no estén disponibles o no tengan 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 "Average inference"

Los resultados de referencia se informan como:

... tflite  : Average inference timings in us: Warmup: 91471, Init: 4108, Inference: 80660.1

Binario de referencia nativo

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

Descarga o crea el binario

Descargue los binarios de línea de comandos nativos preconstruidos nocturnos siguiendo los enlaces a continuación:

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

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

Para compilar con la cadena de herramientas del 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 benchmark

Para ejecutar evaluaciones comparativas 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 que se mencionó anteriormente con el binario de línea de comandos nativo.

Creación de perfiles de operaciones modelo

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 se construye en base a la herramienta de referencia antes mencionada que solo podría 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 BUILD 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 = 'todo')
Una lista separada por comas de opciones de rendimiento de TFLite para comparar.

Puede obtener binarios preconstruidos nocturnos para esta herramienta como se indica a continuación:

aplicación de referencia de iOS

Para ejecutar evaluaciones comparativas en un dispositivo iOS, debe crear la aplicación desde la 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 los 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.

Comparativas de rendimiento de Android

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

Para los puntos de referencia de Android, la afinidad de la CPU está configurada para usar grandes núcleos en el dispositivo para reducir la variación (ver detalles ).

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

Los siguientes valores de rendimiento se miden en Android 10.

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

Comparativas de rendimiento de iOS

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

Para ejecutar evaluaciones comparativas de iOS, se modificó la aplicación de evaluación comparativa para incluir el modelo apropiado y benchmark_params.json se modificó para establecer num_threads en 2. Para usar el delegado de GPU, "use_gpu" : "1" y "gpu_wait_type" : "aggressive" opciones "gpu_wait_type" : "aggressive" fueron 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 (cantidad) iPhone XS 11 ms ---
NASNet móvil 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

Trace los componentes internos de TensorFlow Lite en Android

Los eventos internos del intérprete de TensorFlow Lite de una aplicación de Android se pueden capturar mediante herramientas de seguimiento de Android . Es el mismo evento con la API de Android Trace , 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áficos por delegado
  • Asignación de tensor

Entre las diferentes opciones para capturar trazas, 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.tracing 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 (p. Ej., La invocación del operador) del intérprete.

Después de capturar todas las trazas, inhabilite la traza estableciendo el valor de la propiedad en 0.

adb shell setprop debug.tflite.trace 0

Perfilador de CPU de Android Studio

Capture trazas con el generador de perfiles de CPU de Android Studio siguiendo los pasos a continuación:

  1. Seleccione Ejecutar> Perfil '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 Profiler.

  3. Seleccione 'Rastrear 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 de la traza.

    Seguimiento de Android Studio

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

Aplicación de seguimiento del sistema

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

En este ejemplo, los mismos eventos de TFLite se capturaron y guardaron en el 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 .

Perfetto trace

Usando los datos de rastreo

Los datos de seguimiento le permiten identificar los 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 conducir a un rendimiento inferior. Puede reprogramar otras tareas intensivas de la CPU en su aplicación para evitar superposiciones con la inferencia de su modelo o ajustar el número 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 admitidos similares.