Herramientas de comparación
Actualmente, las herramientas comparativas de TensorFlow Lite miden y calculan las estadísticas de las siguientes métricas de rendimiento importantes:
- Hora de inicialización
- Tiempo de inferencia del estado de calentamiento
- Tiempo de inferencia de estado estable
- Uso de memoria durante el tiempo de inicialización
- Uso general de memoria
Las herramientas comparativas están disponibles como apps de comparativas para iOS y Android, y como objetos binarios de línea de comandos nativos. Además, todas comparten la misma lógica de medición de rendimiento principal. Ten en cuenta que las opciones disponibles y los formatos de salida son un poco diferentes debido a las diferencias en el entorno de ejecución.
App comparativa de Android
Hay dos opciones para usar la herramienta de comparativas con Android. Uno es un binario de comparativas nativo y el otro es una app de comparativas de Android, que permite medir mejor el rendimiento del modelo en la app. De cualquier manera, los números de la herramienta comparativa diferirán un poco de los que se ejecutarán cuando se ejecuten inferencias con el modelo en la app real.
Esta app comparativa de Android no tiene IU. Instálalo y ejecútalo con el comando adb, y recupera los resultados con el comando adb logcat.
Descarga o compila la app
Descarga las apps comparativas de Android compiladas previamente por la noche mediante los siguientes vínculos:
En cuanto a las apps comparativas de Android que admiten ops de TF mediante el delegado de Flex, usa los siguientes vínculos:
También puedes compilar la app desde la fuente siguiendo estas instructions.
Preparar comparativas
Antes de ejecutar la app de comparativas, instala la app 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(predeterminado=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(predeterminado=false)
Usa el delegado XNNPACK.
Según el dispositivo que uses, es posible que algunas de estas opciones no estén disponibles o no tengan efecto. Consulta los 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 comparativos 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 nativo de comparativas
La herramienta de comparativas también se proporciona como un objeto binario nativo benchmark_model. Puedes ejecutar esta herramienta desde una línea de comandos de shell en Linux, Mac, dispositivos incorporados y dispositivos Android.
Descarga o compila el objeto binario
Descarga los objetos binarios de línea de comandos nativos compilados previamente durante la noche mediante los siguientes vínculos:
En cuanto a los objetos binarios compilados previamente que admiten ops de TF mediante el delegado de Flex, usa los siguientes vínculos:
También puedes compilar el objeto binario nativo de comparativas a partir del archivo source en tu computadora.
bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model
Para compilar con la cadena de herramientas del NDK de Android, primero debes configurar el entorno de compilación siguiendo esta guía o usar la imagen de Docker como se describe en esta 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 que se mencionó antes con el objeto binario de línea de comandos nativo.
Operaciones de modelo de generación de perfiles
El objeto binario del modelo de comparativas también te permite generar perfiles de las operaciones de modelo y obtener los tiempos de ejecución de cada operador. Para ello, pasa la marca --enable_op_profiling=true a benchmark_model durante la invocación. Los detalles se explican aquí.
Objeto binario nativo de comparativas para varias opciones de rendimiento en una sola ejecución
También se proporciona un objeto binario de C++ sencillo y conveniente para comparar varias opciones de rendimiento en una sola ejecución. Este objeto binario se compila en función de la herramienta de comparativas antes mencionada, que solo puede comparar una opción de rendimiento a la vez. Comparten el mismo proceso de compilación, instalación y ejecución, pero el nombre de destino de COMPILACIÓN de este objeto binario es benchmark_model_performance_options y toma 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 obtener comparativas.
Puedes obtener objetos binarios compilados previamente durante la noche para esta herramienta, como se indica a continuación:
App comparativa de iOS
Para ejecutar comparativas en dispositivos iOS, debes compilar la app desde la fuente.
Coloca el archivo del modelo de TensorFlow Lite en el directorio benchmark_data del árbol de fuentes y modifica el archivo benchmark_params.json. Esos archivos se empaquetan en la app, que lee los datos del directorio. Visita la app de comparativas de iOS para obtener instrucciones detalladas.
Comparativas de rendimiento para modelos conocidos
En esta sección, se enumeran las comparativas de rendimiento de TensorFlow Lite cuando se ejecutan modelos conocidos en algunos dispositivos iOS y Android.
Comparativas de rendimiento de Android
Estos números de comparativas de rendimiento se generaron con el objeto binario de comparativas nativas.
En el caso de las comparativas de Android, la afinidad de CPU está configurada para usar núcleos grandes en el dispositivo a fin de reducir la variación (consulta los detalles).
Se supone que los modelos se descargaron y se descomprimieron en el directorio /data/local/tmp/tflite_models. El objeto binario comparativo se compila con estas instrucciones y se supone que se encuentra 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 GPU, configura --use_gpu=true.
Los valores de rendimiento que aparecen a continuación se miden en Android 10.
| Nombre del modelo | Dispositivo | CPU, 4 subprocesos | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | Pixel 3 | 23.9 ms | 6.45 ms |
| Pixel 4 | 14.0 ms | 9.0 ms | |
| Mobilenet_1.0_224 (cuantitativa) | Pixel 3 | 13.4 ms | --- |
| Pixel 4 | 5.0 ms | --- | |
| NASNet para dispositivos móviles | Pixel 3 | 56 ms | --- |
| Pixel 4 | 34.5 ms | --- | |
| SqueezeNet | Pixel 3 | 35.8 ms | 9.5 ms |
| Pixel 4 | 23.9 ms | 11.1 ms | |
| Inception_ResNet_V2 | Pixel 3 | 422 ms | 99.8 ms |
| Pixel 4 | 272.6 ms | 87.2 ms | |
| Inception_V4 | Pixel 3 | 486 ms | 93 ms |
| Pixel 4 | 324.1 ms | 97.6 ms |
Comparativas de rendimiento de iOS
Estas cifras de comparativas de rendimiento se generaron con la app de comparativas de iOS.
Para ejecutar comparativas de iOS, se modificó la app comparativa a fin de incluir el modelo adecuado y se modificó benchmark_params.json para establecer num_threads en 2. Para usar el delegado de la GPU, también se agregaron las opciones "use_gpu" : "1" y "gpu_wait_type" : "aggressive" a benchmark_params.json.
| Nombre del modelo | Dispositivo | CPU, 2 subprocesos | GPU |
|---|---|---|---|
| Mobilenet_1.0_224(float) | iPhone XS | 14.8 ms | 3.4 ms |
| Mobilenet_1.0_224 (cuantitativa) | iPhone XS | 11 ms | --- |
| NASNet para dispositivos móviles | 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 |
Hacer un seguimiento de los componentes internos de TensorFlow Lite
Cómo realizar un seguimiento de los componentes internos de TensorFlow Lite en Android
Las herramientas de registro de Android pueden capturar eventos internos del intérprete de TensorFlow Lite de una app para Android. Son los mismos eventos con la API de Trace de Android, por lo que los eventos capturados del código Java o Kotlin se ven junto con los eventos internos de TensorFlow Lite.
Estos son algunos ejemplos de eventos:
- Invocación al operador
- Modificación de gráfico por delegado
- Asignación de tensores
Entre las diferentes opciones para capturar registros, en esta guía, se abordan el Generador de perfiles de CPU de Android Studio y la app de Registro del sistema. Consulta la herramienta de línea de comandos Perfetto o la herramienta de línea de comandos de Systrace para conocer otras opciones.
Agrega eventos de seguimiento en código Java
Este es un fragmento de código de la app de ejemplo 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();
Habilita el seguimiento de TensorFlow Lite
Para habilitar el seguimiento de TensorFlow Lite, establece 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 inicialice el intérprete de TensorFlow Lite, se realizará un seguimiento de los eventos de teclas (p.ej., la invocación del operador) desde el intérprete.
Después de capturar todos los seguimientos, inhabilítalos configurando el valor de la propiedad en 0.
adb shell setprop debug.tflite.trace 0
Generador de perfiles de CPU de Android Studio
Sigue estos pasos para capturar registros con el Generador de perfiles de CPU de Android Studio:
Selecciona Run > Profile 'app' en los menús de la parte superior.
Haz clic en cualquier parte del cronograma de CPU cuando aparezca la ventana de Profiler.
Selecciona “Trace System Calls” entre los modos de generación de perfiles de la CPU.
Presiona el botón “Grabar”.
Presiona el botón "Detener".
Investiga el resultado del seguimiento.
En este ejemplo, puedes ver la jerarquía de eventos de un subproceso y las estadísticas de cada tiempo del operador, así como el flujo de datos de toda la app entre los subprocesos.
La app de Registro del sistema
Captura registros sin Android Studio siguiendo los pasos que se detallan en la app de Registro del sistema.
En este ejemplo, se capturaron los mismos eventos de TFLite y se guardaron en el formato Perfetto o Systrace según la versión del dispositivo Android. Los archivos de registro capturados se pueden abrir en la IU de Perfetto.
Realiza un seguimiento de los componentes internos de TensorFlow Lite en iOS
Los eventos internos del intérprete de TensorFlow Lite de una app para iOS se pueden capturar con la herramienta Instruments, que se incluye con Xcode. Son los eventos indicadores de iOS, por lo que los eventos capturados del código Swift y Objective-C se ven junto con los eventos internos de TensorFlow Lite.
Estos son algunos ejemplos de eventos:
- Invocación al operador
- Modificación de gráfico por delegado
- Asignación de tensores
Habilita el seguimiento de TensorFlow Lite
Para configurar la variable de entorno debug.tflite.trace, sigue estos pasos:
En los menús superiores de Xcode, selecciona Product > Scheme > Edit Scheme....
Haz clic en "Perfil" en el panel izquierdo.
Anula la selección de la casilla de verificación “Usar los argumentos y variables de entorno de la acción de ejecutar”.
Agrega
debug.tflite.traceen la sección "Variables de entorno".
Si quieres excluir los eventos de TensorFlow Lite cuando generes perfiles de la app para iOS, inhabilita el seguimiento quitando la variable de entorno.
Instrumentos de Xcode
Sigue estos pasos para capturar registros:
Selecciona Producto > Perfil en los menús superiores de Xcode.
Haz clic en Logging, entre las plantillas de generación de perfiles, cuando se inicie la herramienta Instruments.
Presiona el botón "Iniciar".
Presiona el botón "Detener".
Haz clic en “os_signpost” para expandir los elementos del subsistema de OS Logging.
Haz clic en el subsistema de Logging del SO “org.tensorflow.lite”.
Investiga el resultado del seguimiento.
En este ejemplo, puedes ver la jerarquía de eventos y estadísticas para el tiempo de cada operador.
Usa los datos de seguimiento
Los datos de seguimiento te permiten identificar cuellos de botella en el rendimiento.
A continuación, se muestran algunos ejemplos de estadísticas que puedes obtener del generador de perfiles y las posibles soluciones para mejorar el rendimiento:
- Si la cantidad de núcleos de CPU disponibles es menor que la cantidad de subprocesos de inferencia, 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 la superposición con la inferencia de tu modelo o ajustar la cantidad de subprocesos de intérprete.
- 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. Puedes sustituir los operadores no admitidos por otros similares.