Quantize

Ejemplo de modo MIN_COMBINED

Suponga que la entrada es de tipo float 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 se convertirá en quint8.

Si el tipo de salida era qint8 ([-128, 127]), la operación restará adicionalmente cada valor por 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 este enfoque se utiliza:

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

Ejemplo de modo ESCALADO

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 escalado se determina a partir `min_range` y` max_range` sea tan grande como sea posible de tal manera que el rango de `` min_range` a max_range` es 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 puede cuantificarse por el recorte de los valores a la gama `min_range` a` max_range`, a continuación, multiplicando por factor_escala como sigue:

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

Atributo de rango estrecho (bool)

Si es cierto, no usamos el valor mínimo cuantificado. 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 se aplica al modo ESCALADO)

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 segmento del tensor a lo largo de esa dimensión. Esto es útil para la cuantificación por canal.

Si se especifica axis, min_range y max_range

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

Atributo asegurar_minimum_range (flotante)

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