Delegados de LiteRT

Los Delegados habilitan la aceleración de hardware de los modelos LiteRT de las siguientes maneras: aprovechando los aceleradores del dispositivo, como la GPU y el procesador de señal digital (DSP).

De forma predeterminada, LiteRT utiliza kernels de CPU que están optimizados para el ARM Neón conjunto de instrucciones. Sin embargo, la CPU es un procesador multipropósito para la aritmética pesada que se suele encontrar en las Modelos de aprendizaje (por ejemplo, la matemática de matrices involucrada en la convolución y la densa capas).

Por otro lado, la mayoría de los teléfonos celulares modernos contienen chips que tienen mejor rendimiento para manejar estas operaciones pesadas. Su uso para operaciones de redes neuronales proporciona enormes beneficios en términos de latencia y eficiencia energética. Por ejemplo: Las GPU pueden proporcionar hasta 5x acelerar de latencia.

Cada uno de estos aceleradores tiene APIs asociadas que permiten procesamientos personalizados, como OpenCL o OpenGL ES para GPU para dispositivos móviles. Por lo general, tendrías escribir mucho código personalizado para ejecutar una red neuronal a través de estas interfaces. La situación se complica aún más cuando consideras que cada acelerador tiene su profesionales y y no puede ejecutar todas las operaciones en una red neuronal. TensorFlow La API de delegado de Lite resuelve este problema actuando como puente entre TFLite y estas APIs de bajo nivel.

entorno de ejecución con delegados

Cómo elegir un delegado

LiteRT admite múltiples delegados, cada uno de los cuales está optimizado para ciertas plataformas y tipos particulares de modelos. Por lo general, habrá varios delegados aplicables a tu caso de uso, según dos criterios principales: la Platform (¿Android o iOS?) a la que orientas los anuncios y el valor Model-type (¿punto flotante o cuantificado?) que estás intentando acelerar.

Delegados por plataforma

Multiplataforma (iOS y Android)

  • Delegado de GPU: El delegado de GPU se puede usar en iOS y Android. Integra está optimizado para ejecutar modelos de 32 y 16 bits basados en números de punto flotante en los que una GPU disponibles. También admite modelos cuantificados de 8 bits y proporciona GPU rendimiento al mismo nivel que sus versiones flotantes. Para obtener más información sobre la GPU delegado, consulta LiteRT en GPU.

iOS

  • Delegado de Core ML para iPhones y iPads más nuevos: Para iPhones y iPads más nuevos En los iPads en los que Neural Engine está disponible, puedes usar el delegado de Core ML para Acelera la inferencia para los modelos de punto flotante de 32 o 16 bits. Neural Engine está disponible en dispositivos móviles Apple con SoC A12 o superior. Para un descripción general del delegado de Core ML y de las instrucciones paso a paso, consulta Delegado de LiteRT Core ML.

Delegados por tipo de modelo

Cada acelerador está diseñado con un cierto ancho de bits de datos en mente. Si proporcionan un modelo de punto flotante a un delegado que solo admite las operaciones, rechazará todas sus operaciones y el modelo se ejecutará por completo la CPU. Para evitar esas sorpresas, la siguiente tabla ofrece una descripción general de y delegar la asistencia según el tipo de modelo:

Tipo de modelo GPU CoreML
Punto flotante (32 bits) Sí Sí
Cuantización de float16 posterior al entrenamiento Sí Sí
Cuantización del rango dinámico posterior al entrenamiento Sí No
Cuantización de números enteros posterior al entrenamiento Sí No
Entrenamiento basado en la cuantización Sí No

Validación del rendimiento

La información de esta sección sirve como una guía para crear una lista reducida de los delegados que podrían mejorar tu postulación. Sin embargo, es importante tener en cuenta que cada delegado tenga un conjunto predefinido de operaciones que admite funcionar de manera diferente según el modelo y el dispositivo. Por lo tanto, suele ser Se recomienda que realices algunas comparativas para medir la utilidad de un delegado según tus necesidades. Esto también ayuda a justificar el aumento de tamaño de los objetos binarios asociado con adjuntar un delegado al entorno de ejecución de LiteRT

LiteRT cuenta con una amplia herramienta de evaluación de la precisión y el rendimiento que puede empoderar a los desarrolladores para que confíen en el uso de delegados en sus aplicaciones. Estas herramientas se analizan en la siguiente sección.

Herramientas de evaluación

Latencia y espacio en memoria

La herramienta de comparativas de LiteRT se puede usar con parámetros adecuados para estimar el rendimiento del modelo, incluida la inferencia promedio latencia, sobrecarga de inicialización, uso de memoria, etc. Esta herramienta admite varias marcas para determinar la mejor configuración de delegado para tu modelo. Para instancia, --gpu_backend=gl se puede especificar con --use_gpu para medir la GPU ejecución con OpenGL. La lista completa de parámetros de delegados admitidos es definidos en la página detallada documentación.

Este es un ejemplo ejecutado para un modelo cuantizado con GPU a través de adb:

adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
  --use_gpu=true

Puedes descargar la versión compilada previamente de esta herramienta para Android, ARM de 64 bits arquitectura aquí (más detalles).

Precisión y precisión

Los delegados suelen realizar cálculos con una precisión diferente a la de su CPU equivalentes. Como resultado, existe una compensación (por lo general menor) en la precisión asociadas con el uso de un delegado para la aceleración de hardware. Ten en cuenta que esta no es siempre verdadera; por ejemplo, como la GPU usa la precisión de punto flotante para ejecutar modelos cuantizados, puede haber una leve mejora en la precisión (p.ej., Menos del 1% de las 5 mejores mejoras en la clasificación de imágenes del ILSVRC).

LiteRT cuenta con dos tipos de herramientas para medir la precisión con la que un delegado se comporta para un modelo determinado: basado en tareas y agnóstico a las tareas. Todas las herramientas descritos en esta sección admiten la delegación avanzada parámetros que usó la herramienta de comparativas de la sección anterior. Ten en cuenta que subsecciones que se encuentran a continuación se enfocan en la evaluación del delegado (¿el delegado realiza igual que la CPU?), en lugar de la evaluación del modelo (¿el modelo en sí es bueno para el tarea?).

Evaluación basada en tareas

LiteRT cuenta con herramientas para evaluar la precisión de dos tareas basadas en imágenes:

Objetos binarios precompilados de estas herramientas (Android, arquitectura ARM de 64 bits), junto con consulta la documentación pertinente aquí:

En el siguiente ejemplo se demuestra la clasificación de imágenes evaluación con GPU en un Pixel 4:

adb shell /data/local/tmp/run_eval \
  --model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
  --ground_truth_images_path=/data/local/tmp/ilsvrc_images \
  --ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
  --model_output_labels=/data/local/tmp/model_output_labels.txt \
  --output_file_path=/data/local/tmp/accuracy_output.txt \
  --num_images=0 # Run on all images. \
  --use_gpu=true

El resultado esperado es una lista de las métricas Top-K del 1 al 10:

Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333

Evaluación independiente de las tareas

Para tareas en las que no hay una herramienta de evaluación integrada en el dispositivo establecida o si están experimentando con modelos personalizados, LiteRT tiene la función Inferencia Diferencia herramienta. (Android, objeto binario de arquitectura binaria ARM de 64 bits aquí).

La diferencia de inferencia compara la ejecución de LiteRT (en términos de latencia y desviación del valor de salida) en dos configuraciones:

  • Inferencia de CPU de un solo subproceso
  • Inferencia definida por el usuario: Definida por estos parámetros

Para ello, la herramienta genera datos gaussianos aleatorios y los pasa por dos Intérpretes de TFLite: uno que ejecuta kernels de CPU de un solo subproceso y el otro parametrizado con los argumentos del usuario.

Mide la latencia de ambos, así como la diferencia absoluta entre los tensores de salida de cada intérprete, por elemento.

Para un modelo con un solo tensor de salida, la salida podría verse de la siguiente manera:

Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06

Esto significa que, para el tensor de salida en el índice 0, los elementos de el resultado de la CPU difiere del resultado del delegado por un promedio de 1.96e-05.

Ten en cuenta que interpretar estos números requiere un conocimiento más profundo del modelo. qué significa cada tensor de salida. Si es una regresión simple que determina algún tipo de puntuación o incorporación, la diferencia debería ser baja (de lo contrario, es un con el delegado). Sin embargo, los resultados como "clase de detección" una de Los modelos SSD son un poco más difíciles de interpretar. Por ejemplo, podría mostrar un con esta herramienta, pero no significa que haya un problema el delegado: considera dos clases (falsas): "TV (ID: 10)" y "Monitor (ID:20)" - Si un delegado se aleja un poco del verdadero verdadero y muestra monitor en lugar de TV, la diferencia de salida para este tensor podría ser algo tan alto como 20-10 = 10.