Quantize

clase final pública Cuantizar

Cuantice el tensor de 'entrada' de tipo flotante al tensor de 'salida' de tipo 'T'.

[min_range, max_range] son ​​flotantes escalares que especifican el rango para los datos de "entrada". El atributo 'modo' controla exactamente qué cálculos se utilizan para convertir los valores flotantes a sus equivalentes cuantificados. El atributo 'round_mode' controla qué algoritmo de desempate de redondeo se utiliza al redondear valores flotantes a sus equivalentes cuantificados.

En el modo 'MIN_COMBINED', cada valor del tensor pasará por lo siguiente:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
 if T == qint8: out[i] -= (range(T) + 1) / 2.0
 
aquí `rango(T) = límites_numéricos ::max() - límites_numéricos ::min()`

Ejemplo de modo MIN_COMBINED

Supongamos que la entrada es de tipo flotante y tiene un rango posible de [0.0, 6.0] y el tipo de salida es quint8 ([0, 255]). Los valores min_range y max_range deben especificarse como 0,0 y 6,0. La cuantificación de float a quint8 multiplicará cada valor de la entrada por 255/6 y lo convertirá a quint8.

Si el tipo de salida fue qint8 ([-128, 127]), la operación restará adicionalmente cada valor en 128 antes de la conversión, de modo que el rango de valores se alinee con el rango de qint8.

Si el modo es 'MIN_FIRST', entonces se utiliza este enfoque:

num_discrete_values = 1 << (# of bits in T)
 range_adjust = num_discrete_values / (num_discrete_values - 1)
 range = (range_max - range_min) * range_adjust
 range_scale = num_discrete_values / range
 quantized = round(input * range_scale) - round(range_min * range_scale) +
   numeric_limits<T>::min()
 quantized = max(quantized, numeric_limits<T>::min())
 quantized = min(quantized, numeric_limits<T>::max())
 
La mayor diferencia entre esto y MIN_COMBINED es que el rango mínimo se redondea primero, antes de restarlo del valor redondeado. Con MIN_COMBINED, se introduce un pequeño sesgo en el que las iteraciones repetidas de cuantificación y descuantificación introducirán un error cada vez mayor.

Modo ESCALA Ejemplo

El modo `SCALED` coincide con el enfoque de cuantificación utilizado en `QuantizeAndDequantize{V2|V3}`.

Si el modo es "ESCALADO", la cuantificación se realiza multiplicando cada valor de entrada por un factor de escala. El factor de escala se determina a partir de `min_range` y `max_range` para que sea lo más grande posible, de modo que el rango de `min_range` a `max_range` sea representable dentro de valores de tipo T.

const int min_T = std::numeric_limits<T>::min();
   const int max_T = std::numeric_limits<T>::max();
   const float max_float = std::numeric_limits<float>::max();
 
   const float scale_factor_from_min_side =
       (min_T * min_range > 0) ? min_T / min_range : max_float;
   const float scale_factor_from_max_side =
       (max_T * max_range > 0) ? max_T / max_range : max_float;
 
   const float scale_factor = std::min(scale_factor_from_min_side,
                                       scale_factor_from_max_side);
 
A continuación usamos scale_factor para ajustar min_range y max_range de la siguiente manera:
min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 
por ejemplo, si T = qint8, e inicialmente min_range = -10 y max_range = 9, compararíamos -128/-10,0 = 12,8 con 127/9,0 = 14,11 y estableceríamos scaling_factor = 12,8. En este caso, min_range permanecería -10, pero max_range se ajustaría a 127/12,8 = 9,921875

Por tanto, cuantificaremos los valores de entrada en el rango (-10, 9,921875) a (-128, 127).

El tensor de entrada ahora se puede cuantificar recortando los valores del rango `min_range` a `max_range` y luego multiplicando por scale_factor de la siguiente manera:

result = round(min(max_range, max(min_range, input)) * scale_factor)
 
Los `min_range` y max_range` ajustados se devuelven como salidas 2 y 3 de esta operación. Estas salidas deben usarse como rango para cualquier cálculo adicional.

atributo de rango estrecho (bool)

Si es cierto, no utilizamos el valor cuantificado mínimo. es decir, para int8 la salida cuantificada, estaría restringida al rango -127..127 en lugar del rango completo -128..127. Esto se proporciona por compatibilidad con ciertos backends de inferencia. (Solo aplica al modo ESCALA)

atributo de eje (int)

Un atributo opcional de "eje" puede especificar un índice de dimensión del tensor de entrada, de modo que los rangos de cuantificación se calcularán y aplicarán por separado para cada porción del tensor a lo largo de esa dimensión. Esto es útil para la cuantificación por canal.

Si se especifica el eje, min_range y max_range

si `axis`=Ninguno, la cuantificación por tensor se realiza normalmente.

atributo sure_minimum_range (flotante)

Garantiza que el rango mínimo de cuantificación sea al menos este valor. El valor predeterminado heredado para esto es 0,01, pero se recomienda establecerlo en 0 para nuevos usos.

Clases anidadas

clase Opciones de cuantización Atributos opcionales para Quantize

Constantes

Cadena OP_NOMBRE El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Métodos públicos

Opciones de cuantización estática
eje (eje largo)
estático <T extiende TType > Cuantizar <T>
crear (alcance alcance , operando <TFloat32> entrada, operando <TFloat32> minRange, operando <TFloat32> maxRange, clase<T> T, opciones... opciones)
Método de fábrica para crear una clase que envuelve una nueva operación de cuantización.
Opciones de cuantización estática
asegurarMinimumRange (flotante asegurarMinimumRange)
Opciones de cuantización estática
modo (modo cadena)
Opciones de cuantización estática
rango estrecho (rango estrecho booleano)
Salida <T>
producción ()
Los datos cuantificados producidos a partir de la entrada flotante.
Salida <TFloat32>
salidaMax ()
El rango máximo de cuantificación final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados.
Salida <TFloat32>
salidaMin ()
El rango mínimo de cuantificación final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados.
Opciones de cuantización estática
roundMode (cadena roundMode)

Métodos heredados

Constantes

Cadena final estática pública OP_NAME

El nombre de esta operación, como lo conoce el motor central de TensorFlow.

Valor constante: "QuantizeV2"

Métodos públicos

eje público estático Quantize.Options (eje largo)

public static Quantize <T> create ( alcance alcance , Operando <TFloat32> entrada, Operando <TFloat32> minRange, Operando <TFloat32> maxRange, Clase<T> T, Opciones... opciones)

Método de fábrica para crear una clase que envuelve una nueva operación de cuantización.

Parámetros
alcance alcance actual
rango mínimo El valor mínimo del rango de cuantificación. Este valor puede ser ajustado por el operador dependiendo de otros parámetros. El valor ajustado se escribe en `output_min`. Si se especifica el atributo "eje", debe ser un tensor 1-D cuyo tamaño coincida con la dimensión del "eje" de los tensores de entrada y salida.
rango máximo El valor máximo del rango de cuantificación. Este valor puede ser ajustado por el operador dependiendo de otros parámetros. El valor ajustado se escribe en `output_max`. Si se especifica el atributo "eje", debe ser un tensor 1-D cuyo tamaño coincida con la dimensión del "eje" de los tensores de entrada y salida.
opciones lleva valores de atributos opcionales
Devoluciones
  • una nueva instancia de Quantize

Quantize.Options estático público asegurarMinimumRange (Float asegurarMinimumRange)

modo público estático Quantize.Options (modo cadena)

Quantize.Options estático público de rango estrecho (rango estrecho booleano)

Salida pública <T> salida ()

Los datos cuantificados producidos a partir de la entrada flotante.

Salida pública <TFloat32> salidaMax ()

El rango máximo de cuantificación final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados. Si se especifica el atributo "eje", será un tensor 1-D cuyo tamaño coincide con la dimensión del "eje" de los tensores de entrada y salida.

Salida pública <TFloat32> salidaMin ()

El rango mínimo de cuantificación final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados. Si se especifica el atributo "eje", será un tensor 1-D cuyo tamaño coincide con la dimensión del "eje" de los tensores de entrada y salida.

Quantize.Options estático público roundMode (String roundMode)