flujo tensor:: operaciones:: CuantizarV2

#include <array_ops.h>

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

Resumen

[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í range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::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::min()
quantized = max(quantized, numeric_limits::min())
quantized = min(quantized, numeric_limits::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 SCALED , 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::min();
  const int max_T = std::numeric_limits::max();
  const float max_float = std::numeric_limits::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 al 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 valores 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 axis opcional puede especificar un índice de dimensión del tensor de entrada, de modo que los rangos de cuantificación se calculen y apliquen 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.
 Argumentos:
  •  alcance: un objeto de alcance
  •  min_range: 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 axis , debe ser un tensor 1-D cuyo tamaño coincida con la dimensión del axis de los tensores de entrada y salida.
  •  max_range: 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 axis , debe ser un tensor 1-D cuyo tamaño coincida con la dimensión del axis de los tensores de entrada y salida.
 Devoluciones:
  •  Salida Output : los datos cuantificados producidos a partir de la entrada flotante.
  •  Output output_min: el mínimo del rango de cuantificación final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados. Si se especifica el atributo axis , será un tensor 1-D cuyo tamaño coincide con la dimensión del axis de los tensores de entrada y salida.
  •  Output output_max: 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 axis , será un tensor 1-D cuyo tamaño coincide con la dimensión del axis de los tensores de entrada y salida. 
 Constructores y destructores
 QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T)
 QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T, const QuantizeV2::Attrs & attrs)
 
 Atributos públicos
 operation
 output
 output_max
 output_min 
Funciones estáticas públicas
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool x)
 RoundMode (StringPiece x) 
 estructuras
 tensorflow:: operaciones:: QuantizeV2:: Atributos
 Configuradores de atributos opcionales para QuantizeV2 .
 Atributos públicos 
 operación
 
Operation operation
 
 producción
 
::tensorflow::Output output
 
 salida_max
 
::tensorflow::Output output_max
 
 salida_min
 
::tensorflow::Output output_min
 Funciones públicas 
 CuantizarV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 
 CuantizarV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)
 Funciones estáticas públicas 
 Eje
 
Attrs Axis(
  int64 x
)
 
 Garantizar el rango mínimo
 
Attrs EnsureMinimumRange(
  float x
)
 
 Modo
 
Attrs Mode(
  StringPiece x
)
 
 Rango estrecho
 
Attrs NarrowRange(
  bool x
)
 
 Modo redondo
 
Attrs RoundMode(
  StringPiece x
)