tensorflow:: ops:: QuantizeV2

#include <array_ops.h>

Cuantiza el tensor de 'entrada' de tipo float a un tensor de 'salida' de tipo 'T'.

Resumen

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

En el modo 'MIN_COMBINED', cada valor del tensor se someterá a 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()

Ejemplo de modo MIN_COMBINED

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

Si el tipo de salida era qint8 ([-128, 127]), la operación restará adicionalmente 128 a cada valor 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 principal diferencia entre esta función y MIN_COMBINED radica en que el rango mínimo se redondea primero, antes de restarlo del valor redondeado. Con MIN_COMBINED, se introduce un pequeño sesgo, ya que las iteraciones repetidas de cuantificación y descuantización generan un error cada vez mayor.

Ejemplo de modo ESCALAR

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

Si el modo es SCALED , la cuantizació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 desde min_range hasta 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, utilizamos el factor de escala 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 seguiría siendo -10, pero max_range se ajustaría a 127 / 12.8 = 9.921875.
 Así que cuantificaremos los valores de entrada en el rango (-10, 9.921875) a (-128, 127).
 Ahora se puede cuantificar el tensor de entrada recortando los valores al rango min_range a max_range y luego multiplicándolos 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 resultados 2 y 3 de esta operación. Estos resultados deben utilizarse como rango para cualquier cálculo posterior.
 atributo narrow_range (booleano)
 Si es cierto, no utilizamos el valor mínimo cuantificado. Es decir, para int8, la salida cuantificada se limitaría al rango -127..127 en lugar del rango completo -128..127. Esto se proporciona para garantizar la compatibilidad con ciertos backends de inferencia. (Solo se aplica al modo ESCALED).
 atributo eje (int)
 Un atributo axis opcional permite especificar un índice de dimensión del tensor de entrada, de modo que los rangos de cuantización se calculen y apliquen por separado para cada segmento del tensor a lo largo de esa dimensión. Esto resulta útil para la cuantización por canal.
 Si se especifica el eje, min_range y max_range
 Si axis =None, la cuantización por tensor se realiza de forma normal.
 atributo ensure_minimum_range (float)
 Garantiza que el rango mínimo de cuantización sea al menos este valor. El valor predeterminado anterior es 0,01, pero se recomienda encarecidamente establecerlo en 0 para nuevos usos.
 Argumentos:
  •  ámbito: Un objeto de ámbito
  •  min_range: El valor mínimo del rango de cuantización. Este valor puede ser ajustado por el operador en función de otros parámetros. El valor ajustado se escribe en output_min . Si se especifica el atributo axis , este debe ser un tensor unidimensional cuyo tamaño coincida con la dimensión axis de los tensores de entrada y salida.
  •  max_range: El valor máximo del rango de cuantización. Este valor puede ser ajustado por el operador en función de otros parámetros. El valor ajustado se escribe en output_max . Si se especifica el atributo axis , este debe ser un tensor unidimensional cuyo tamaño coincida con la dimensión axis de los tensores de entrada y salida.
 Devoluciones:
  •  Output : Los datos cuantificados producidos a partir de la entrada de punto flotante.
  •  Output output_min: El mínimo del rango de cuantización final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantizados. Si se especifica el atributo axis , será un tensor unidimensional cuyo tamaño coincide con la dimensión axis de los tensores de entrada y salida.
  •  Output output_max: El máximo del rango de cuantización final, utilizado para recortar los valores de entrada antes de escalarlos y redondearlos a valores cuantizados. Si se especifica el atributo axis , será un tensor unidimensional cuyo tamaño coincide con la dimensión 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
 salida_máx 
::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
)
 Asegurar rango mínimo 
Attrs EnsureMinimumRange(
  float x
)
 Modo 
Attrs Mode(
  StringPiece x
)
 Rango estrecho 
Attrs NarrowRange(
  bool x
)
 Modo redondo 
Attrs RoundMode(
  StringPiece x
)