Se usó la API de Cloud Translation para traducir esta página.
Switch to English

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 donde 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 , no usamos el rango completo del tipo de salida, eligiendo elidir 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 asigna a 0.

Primero encontramos el rango de valores en nuestro tensor. El rango que usamos siempre se centra 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 cubos de cuantificación de punto fijo, [min_fixed, max_fixed] . Si T está firmado, 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 está firmado, 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ínimos y máximos solicitados durante el proceso de cuantificación, por lo que siempre debe usar los puertos de salida como rango para cálculos adicionales. Por ejemplo, si los valores mínimo y máximo solicitados son casi iguales, estarán separados por un pequeño valor épsilon para evitar que se creen búferes cuantificados mal formados. De lo contrario, puede terminar con búferes donde todos los valores cuantificados se asignan al mismo valor flotante, lo que causa problemas para las operaciones que tienen que realizar cálculos adicionales sobre ellos.

Argumentos:

  • alcance: un objeto de alcance
  • min_range: el valor escalar mínimo que posiblemente se produzca para la entrada.
  • max_range: el valor escalar máximo que se puede producir para la entrada.

Devoluciones:

  • Output salida: 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 :: ops :: QuantizeV2 :: Attrs

Configuradores de atributos opcionales para QuantizeV2 .

Atributos públicos

operación

Operation operation

salida

::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

Modo

Attrs Mode(
  StringPiece x
)

RoundMode

Attrs RoundMode(
  StringPiece x
)