Quantize

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())
 

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);
 

min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 

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`, luego multiplicando por scale_factor de la siguiente manera:

result = round(min(max_range, max(min_range, input)) * scale_factor)
 

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.