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

Cuantización posterior al entrenamiento

La cuantificación posterior al entrenamiento es una técnica de conversión que puede reducir el tamaño del modelo y al mismo tiempo mejorar la latencia del acelerador de CPU y hardware, con poca degradación en la precisión del modelo. Puede cuantificar un modelo de TensorFlow flotante ya entrenado cuando lo convierte al formato TensorFlow Lite con TensorFlow Lite Converter .

Métodos de optimización

Hay varias opciones de cuantificación posterior al entrenamiento para elegir. A continuación, se muestra una tabla de resumen de las opciones y los beneficios que brindan:

Técnica Beneficios Hardware
Cuantización de rango dinámico 4 veces más pequeño, aceleración 2x-3x UPC
Cuantización completa de enteros 4 veces más pequeño, 3 veces más rápido CPU, Edge TPU, Microcontroladores
Cuantificación Float16 Aceleración de GPU 2 veces más pequeña CPU, GPU

El siguiente árbol de decisiones puede ayudar a determinar qué método de cuantificación posterior al entrenamiento es mejor para su caso de uso:

opciones de optimización post-entrenamiento

Cuantización de rango dinámico

La forma más simple de cuantificación posterior al entrenamiento cuantifica estáticamente solo los pesos desde el punto flotante hasta el entero, que tiene 8 bits de precisión:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

En la inferencia, los pesos se convierten de 8 bits de precisión a punto flotante y se calculan usando núcleos de punto flotante. Esta conversión se realiza una vez y se almacena en caché para reducir la latencia.

Para mejorar aún más la latencia, los operadores de "rango dinámico" cuantifican dinámicamente las activaciones según su rango a 8 bits y realizan cálculos con ponderaciones y activaciones de 8 bits. Esta optimización proporciona latencias cercanas a la inferencia de punto fijo. Sin embargo, las salidas todavía se almacenan usando punto flotante, de modo que la aceleración con operaciones de rango dinámico es menor que un cálculo completo de punto fijo.

Cuantización completa de enteros

Puede obtener más mejoras de latencia, reducciones en el uso máximo de memoria y compatibilidad con aceleradores o dispositivos de hardware de solo números enteros asegurándose de que todas las matemáticas del modelo estén cuantificadas en números enteros.

Para la cuantificación completa de enteros, debe medir el rango dinámico de activaciones y entradas suministrando datos de entrada de muestra al convertidor. Consulte la función representative_dataset_gen() utilizada en el siguiente código.

Entero con retroceso flotante (usando la entrada / salida flotante predeterminada)

Para cuantificar completamente un modelo con números enteros, pero use operadores flotantes cuando no tienen una implementación de números enteros (para garantizar que la conversión se realice sin problemas), siga los siguientes pasos:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
tflite_quant_model = converter.convert()

Entero solamente

La creación de modelos de solo enteros es un caso de uso común de TensorFlow Lite para microcontroladores y TPU Coral Edge .

Además, para garantizar la compatibilidad con dispositivos de solo enteros (como microcontroladores de 8 bits) y aceleradores (como Coral Edge TPU), puede aplicar la cuantificación completa de enteros para todas las operaciones, incluida la entrada y la salida, mediante los siguientes pasos:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8  # or tf.uint8
tflite_quant_model = converter.convert()

Cuantificación Float16

Puede reducir el tamaño de un modelo de punto flotante cuantificando los pesos a float16, el estándar IEEE para números de punto flotante de 16 bits. Para habilitar la cuantificación de pesos de float16, utilice los siguientes pasos:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_quant_model = converter.convert()

Las ventajas de la cuantificación float16 son las siguientes:

  • Reduce el tamaño del modelo hasta la mitad (ya que todos los pesos se convierten en la mitad de su tamaño original).
  • Causa una mínima pérdida de precisión.
  • Es compatible con algunos delegados (por ejemplo, el delegado de la GPU) que pueden operar directamente en los datos de float16, lo que resulta en una ejecución más rápida que los cálculos de float32.

Las desventajas de la cuantificación float16 son las siguientes:

  • No reduce la latencia tanto como una cuantificación a matemáticas de punto fijo.
  • De forma predeterminada, un modelo cuantificado float16 "descuantificará" los valores de ponderación a float32 cuando se ejecute en la CPU. (Tenga en cuenta que el delegado de la GPU no realizará esta descuantificación, ya que puede operar con datos float16).

Solo entero: activaciones de 16 bits con pesos de 8 bits (experimental)

Este es un esquema de cuantificación experimental. Es similar al esquema "solo entero", pero las activaciones se cuantifican en función de su rango a 16 bits, los pesos se cuantifican en números enteros de 8 bits y el sesgo se cuantifica en números enteros de 64 bits. Esto se conoce además como cuantificación 16x8.

La principal ventaja de esta cuantificación es que puede mejorar la precisión de manera significativa, pero solo aumenta ligeramente el tamaño del modelo.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]
tflite_quant_model = converter.convert()

Si la cuantificación 16x8 no es compatible con algunos operadores en el modelo, entonces el modelo aún puede cuantificarse, pero los operadores no compatibles se mantienen flotando. La siguiente opción debe agregarse a target_spec para permitir esto.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8,
tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_quant_model = converter.convert()

Ejemplos de casos de uso en los que las mejoras de precisión proporcionadas por este esquema de cuantificación incluyen: * superresolución, * procesamiento de señales de audio como cancelación de ruido y formación de haces, * eliminación de ruido de imágenes, * reconstrucción HDR a partir de una sola imagen.

La desventaja de esta cuantificación es:

  • Actualmente, la inferencia es notablemente más lenta que el entero completo de 8 bits debido a la falta de implementación optimizada del kernel.
  • Actualmente es incompatible con los delegados TFLite acelerados por hardware existentes.

Puede encontrar un tutorial para este modo de cuantificación aquí .

Precisión del modelo

Dado que los pesos se cuantifican después del entrenamiento, podría haber una pérdida de precisión, especialmente para redes más pequeñas. Se proporcionan modelos completamente cuantificados previamente entrenados para redes específicas en el repositorio de modelos de TensorFlow Lite . Es importante verificar la precisión del modelo cuantificado para verificar que cualquier degradación en la precisión esté dentro de límites aceptables. Existen herramientas para evaluar la precisión del modelo de TensorFlow Lite .

Alternativamente, si la caída de la precisión es demasiado alta, considere usar el entrenamiento consciente de cuantificación . Sin embargo, hacerlo requiere modificaciones durante el entrenamiento del modelo para agregar nodos de cuantificación falsos, mientras que las técnicas de cuantificación posteriores al entrenamiento en esta página utilizan un modelo existente previamente entrenado.

Representación para tensores cuantificados

La cuantificación de 8 bits se aproxima a los valores de punto flotante utilizando la siguiente fórmula.

$$real\_value = (int8\_value - zero\_point) \times scale$$

La representación tiene dos partes principales:

  • Los pesos por eje (también conocido como por canal) o por tensor representados por valores de complemento a dos de int8 en el rango [-127, 127] con punto cero igual a 0.

  • Activaciones / entradas por tensor representadas por int8 valores de complemento a dos en el rango [-128, 127], con un punto cero en el rango [-128, 127].

Para obtener una vista detallada de nuestro esquema de cuantificación, consulte nuestra especificación de cuantificación . Se recomienda a los proveedores de hardware que deseen conectarse a la interfaz de delegado de TensorFlow Lite que implementen el esquema de cuantificación que se describe allí.