tensorflow :: operaciones :: QuantizeV2

#include <array_ops.h>

Cuantifique el tensor de 'entrada' de tipo float al tensor de 'salida' de tipo 'T'.

Resumen

[rango_mín, rango_máx] 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 redondeo de desempate se utiliza al redondear los 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

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', 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.

Ejemplo de modo ESCALADO

SCALED 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 del min_range y el max_range para que sea lo más grande posible, de modo que el rango desde el min_range al max_range se max_range representar dentro de los 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);

 Luego usamos scale_factor para ajustar min_range y max_range como sigue:
 
      min_range = min_T / scale_factor;
      max_range = max_T / scale_factor;

 Por ejemplo, si T = qint8, e inicialmente rango_mín = -10 y rango_máx = 9, compararíamos -128 / -10.0 = 12.8 con 127 / 9.0 = 14.11, y estableceríamos factor_escalado = 12.8 En este caso, rango_mín seguiría siendo -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 , luego multiplicando por scale_factor de la siguiente manera:
 
result = round(min(max_range, max(min_range, input)) * scale_factor)

 El min_range ajustado y el max_range se devuelven como salidas 2 y 3 de esta operación. Estos resultados deben usarse como rango para cualquier cálculo adicional.
 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 de axis opcional 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.
 Argumentos:
  •  alcance: un objeto de alcance
  •  min_range: el valor mínimo del rango de cuantificación. Este valor puede ser ajustado por la operación dependiendo de otros parámetros. El valor ajustado se escribe en output_min . Si se especifica el atributo del axis , este 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 la operación dependiendo de otros parámetros. El valor ajustado se escribe en output_max . Si se especifica el atributo del axis , este debe ser un tensor 1-D cuyo tamaño coincida con la dimensión del axis de los tensores de entrada y salida.
 Devoluciones:
  •  Output salida: los datos cuantificados producidos a partir de la entrada flotante.
  •  Output output_min: El mínimo del rango de cuantificación final, que se utiliza para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados. Si se especifica el atributo del axis , este 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 máximo del rango de cuantificación final, que se utiliza para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantificados. Si se especifica el atributo del axis , este 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 :: ops :: QuantizeV2 :: Attrs
 Configuradores de atributos opcionales para QuantizeV2 .
 Atributos públicos 
 operación
 
Operation operation
 
 producción
 
::tensorflow::Output output
 
 output_max
 
::tensorflow::Output output_max
 
 output_min
 
::tensorflow::Output output_min
 Funciones publicas 
 QuantizeV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 
 QuantizeV2
 
 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
)
 
 GarantizarRango Mínimo
 
Attrs EnsureMinimumRange(
  float x
)
 
 Modo
 
Attrs Mode(
  StringPiece x
)
 
 Rango estrecho
 
Attrs NarrowRange(
  bool x
)
 
 RoundMode
 
Attrs RoundMode(
  StringPiece x
)