Delegados de GPU para TensorFlow Lite

El uso de unidades de procesamiento gráfico (GPU) para ejecutar tus modelos de aprendizaje automático (AA) puede mejorar drásticamente el rendimiento de tu modelo y la experiencia del usuario de tus aplicaciones habilitadas para el AA. TensorFlow Lite permite el uso de GPU y otros procesadores especializados a través de un controlador de hardware denominado delegados. Habilitar el uso de GPU con tus aplicaciones de AA de TensorFlow Lite puede proporcionar los siguientes beneficios:

• Velocidad: Las GPU están diseñadas para una alta capacidad de procesamiento de cargas de trabajo paralelas de forma masiva. Este diseño las hace adecuadas para las redes neuronales profundas, que constan de una gran cantidad de operadores, cada uno de los cuales trabaja con tensores de entrada que se pueden procesar en paralelo, lo que suele dar como resultado una latencia más baja. En la mejor situación, ejecutar tu modelo en una GPU puede ejecutarse lo suficientemente rápido como para habilitar aplicaciones en tiempo real que antes no eran posibles.
• Eficiencia energética: Las GPU realizan cálculos de AA de manera muy eficiente y optimizada, por lo general, consumen menos energía y generan menos calor que la misma tarea que se ejecuta en las CPU.

En este documento, se proporciona una descripción general de la compatibilidad con GPU en TensorFlow Lite y algunos usos avanzados de los procesadores de GPU. Para obtener información más específica sobre la implementación de la compatibilidad con GPU en plataformas específicas, consulta las siguientes guías:

• Compatibilidad de GPU para Android
• Compatibilidad de GPU para iOS

Compatibilidad con operaciones de AA de GPU

El delegado de la GPU de TensorFlow Lite puede acelerar las operaciones del AA de TensorFlow o las operaciones de TensorFlow Lite. El delegado admite las siguientes operaciones en la precisión de número de punto flotante para 16 y 32 bits:

• ADD
• AVERAGE_POOL_2D
• CONCATENATION
• CONV_2D
• DEPTHWISE_CONV_2D v1-2
• EXP
• FULLY_CONNECTED
• LOGICAL_AND
• LOGISTIC
• LSTM v2 (Basic LSTM only)
• MAX_POOL_2D
• MAXIMUM
• MINIMUM
• MUL
• PAD
• PRELU
• RELU
• RELU6
• RESHAPE
• RESIZE_BILINEAR v1-3
• SOFTMAX
• STRIDED_SLICE
• SUB
• TRANSPOSE_CONV

De forma predeterminada, todas las operaciones solo se admiten en la versión 1. Si habilitas la compatibilidad con cuantización, se habilitarán las versiones adecuadas, por ejemplo, ADD v2.

Solución de problemas de compatibilidad con GPU

Si el delegado de la GPU no admite algunas de las operaciones, el framework solo ejecutará una parte del grafo en la GPU y la parte restante en la CPU. Debido al alto costo de la sincronización de CPU/GPU, un modo de ejecución dividida como este suele generar un rendimiento más lento que cuando toda la red se ejecuta solo en la CPU. En este caso, la aplicación genera una advertencia, como la siguiente:

WARNING: op code #42 cannot be handled by this delegate.

No hay devolución de llamada para fallas de este tipo, ya que no es una falla real en el tiempo de ejecución. Cuando pruebes la ejecución de tu modelo con el delegado de la GPU, deberías estar alerta para estas advertencias. Una gran cantidad de estas advertencias puede indicar que tu modelo no es la mejor opción para usar la aceleración de GPU y puede requerir una refactorización del modelo.

Modelos de ejemplo

Los siguientes modelos de ejemplo se diseñaron para aprovechar la aceleración de GPU con TensorFlow Lite y se proporcionan como referencia y pruebas:

• Clasificación de imágenes MobileNet v1 (224 x 224): Un modelo de clasificación de imágenes diseñado para aplicaciones de visión incorporadas y móviles. (model)
• Segmentación de DeepLab (257 x 257): Es un modelo de segmentación de imágenes que asigna etiquetas semánticas, como perro, gato o automóvil, a cada píxel de la imagen de entrada. (model)
• Detección de objetos SSD de MobileNet: Es un modelo de clasificación de imágenes que detecta varios objetos con cuadros delimitadores. (model)
• PoseNet para la estimación de poses: Es un modelo de visión que estima las poses de las personas en imágenes o videos. (model)

Optimiza para GPU

Las siguientes técnicas pueden ayudarte a obtener un mejor rendimiento cuando ejecutas modelos en hardware de GPU con el delegado de GPU de TensorFlow Lite:

• Operaciones de cambio de forma: Algunas operaciones rápidas en una CPU pueden tener un costo alto para la GPU en dispositivos móviles. Las operaciones de cambio de forma son particularmente costosas de ejecutar, incluidas BATCH_TO_SPACE, SPACE_TO_BATCH, SPACE_TO_DEPTH, etcétera. Debes examinar con detenimiento el uso de operaciones de remodelación y considerar que se puede haber aplicado solo para explorar datos o para iteraciones iniciales de tu modelo. Quitarlas puede mejorar significativamente el rendimiento.

• Canales de datos de imágenes: en la GPU, los datos del tensor se dividen en 4 canales, por lo que un cálculo en un tensor con la forma [B,H,W,5] funciona casi igual en un tensor de forma [B,H,W,8], pero mucho peor que [B,H,W,4]. Si el hardware de cámara que usas admite marcos de imagen en RGBA, enviar esa entrada de 4 canales es mucho más rápido, ya que evita una copia de memoria de RGB de 3 canales a RGBX de 4 canales.

• Modelos optimizados para dispositivos móviles: Para obtener el mejor rendimiento, deberías considerar volver a entrenar tu clasificador con una arquitectura de red optimizada para dispositivos móviles. La optimización para la inferencia integrada en el dispositivo puede reducir drásticamente la latencia y el consumo de energía mediante las funciones de hardware para dispositivos móviles.

Compatibilidad avanzada con GPU

Puedes usar técnicas adicionales y avanzadas con el procesamiento de GPU para permitir un rendimiento aún mejor para tus modelos, incluidas la cuantización y la serialización. En las siguientes secciones, se describen estas técnicas con más detalle.

Cómo usar modelos cuantizados

En esta sección, se explica cómo el delegado de la GPU acelera los modelos cuantizados de 8 bits, incluidos los siguientes:

• Modelos entrenados con el entrenamiento que tiene en cuenta la cuantización
• Cuantización del rango dinámico posterior al entrenamiento
• Cuantización de número entero posterior al entrenamiento

Para optimizar el rendimiento, usa modelos que tengan tensores de entrada y salida de punto flotante.

¿Cómo funciona?

Dado que el backend de la GPU solo admite la ejecución de punto flotante, ejecutamos modelos cuantificados con una “vista de punto flotante” del modelo original. En un nivel alto, esto implica los pasos siguientes:

• Los tensores constantes (como los pesos/sesgos) se descuantizan una vez en la memoria de la GPU. Esta operación ocurre cuando se habilita el delegado en TensorFlow Lite.

• Las entradas y salidas del programa de GPU, si son de 8 bits, se descuantizan y cuantizan (respectivamente) para cada inferencia. Esta operación se realiza en la CPU con los kernels optimizados de TensorFlow Lite.

• Los simuladores de cuantización se insertan entre operaciones para imitar el comportamiento cuantizado. Este enfoque es necesario para los modelos en los que las operaciones esperan que las activaciones sigan los límites aprendidos durante la cuantización.

Para obtener información sobre cómo habilitar esta función con el delegado de la GPU, consulta lo siguiente:

• Usar modelos cuantizados con GPU en Android
• Usar modelos cuantizados con GPU en iOS

Reduce el tiempo de inicialización con la serialización

La función de delegado de GPU te permite cargar desde código de kernel compilado previamente y datos del modelo serializados y guardados en el disco de ejecuciones anteriores. Este enfoque evita la recompilación y puede reducir el tiempo de inicio hasta en un 90%. Esta mejora se logra intercambiando espacio en disco para ahorrar tiempo. Puedes habilitar esta función con algunas opciones de configuración, como se muestra en los siguientes ejemplos de código:

    TfLiteGpuDelegateOptionsV2 options = TfLiteGpuDelegateOptionsV2Default();
    options.experimental_flags |= TFLITE_GPU_EXPERIMENTAL_FLAGS_ENABLE_SERIALIZATION;
    options.serialization_dir = kTmpDir;
    options.model_token = kModelToken;

    auto* delegate = TfLiteGpuDelegateV2Create(options);
    if (interpreter->ModifyGraphWithDelegate(delegate) != kTfLiteOk) return false;
      

    GpuDelegate delegate = new GpuDelegate(
      new GpuDelegate.Options().setSerializationParams(
        /* serializationDir= */ serializationDir,
        /* modelToken= */ modelToken));

    Interpreter.Options options = (new Interpreter.Options()).addDelegate(delegate);
      

Cuando uses la función de serialización, asegúrate de que tu código cumpla con estas reglas de implementación:

• Almacena los datos de serialización en un directorio al que otras apps no puedan acceder. En los dispositivos Android, usa getCodeCacheDir(), que apunta a una ubicación que sea privada para la aplicación actual.
• El token de modelo debe ser único para el dispositivo del modelo específico. Puedes calcular un token de modelo generando una huella digital a partir de los datos del modelo mediante bibliotecas como farmhash::Fingerprint64.