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 , no usamos el rango completo del tipo de salida, eligiendo omitir el valor más bajo posible para la simetría (por ejemplo, el rango de salida es -127 a 127, no -128 a 127 para la cuantificación de 8 bits con signo). de modo que 0.0 se asigne a 0.

Primero encontramos el rango de valores en nuestro tensor. El rango que utilizamos siempre está centrado en 0, por lo que encontramos m tal que

  m = max(abs(input_min), abs(input_max))

Nuestro rango de tensor de entrada es entonces [-m, m] .

A continuación, elegimos nuestros depósitos de cuantificación de punto fijo, [min_fixed, max_fixed] . Si T tiene signo, esto es

  num_bits = sizeof(T) * 8
  [min_fixed, max_fixed] =
      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]

De lo contrario, si T no tiene signo, el rango de punto fijo es

  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]

A partir de esto calculamos nuestro factor de escala, s:

  s = (max_fixed - min_fixed) / (2 * m)

Ahora podemos cuantificar los elementos de nuestro tensor:

result = round(input * s)

Una cosa a tener en cuenta es que el operador puede optar por ajustar ligeramente los valores mínimo y máximo solicitados durante el proceso de cuantificación, por lo que siempre debe utilizar los puertos de salida como rango para cálculos adicionales. Por ejemplo, si los valores mínimo y máximo solicitados son casi iguales, se separarán por un pequeño valor épsilon para evitar que se creen buffers cuantificados mal formados. De lo contrario, puede terminar con buffers donde todos los valores cuantificados se asignan al mismo valor flotante, lo que causa problemas para las operaciones que tienen que realizar más cálculos sobre ellos.

Argumentos:

  • alcance: un objeto de alcance
  • min_range: el valor escalar mínimo posiblemente producido para la entrada.
  • max_range: el valor escalar máximo posiblemente producido para la entrada.

Devoluciones:

  • Salida Output : los datos cuantificados producidos a partir de la entrada flotante.
  • Output output_min: el valor escalar mínimo real utilizado para la salida.
  • Output output_max: el valor escalar máximo real utilizado para la 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

Mode (StringPiece 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

Modo 

Attrs Mode(
  StringPiece x
)

Modo redondo

Attrs RoundMode(
  StringPiece x
)