tensorflow :: ops :: QuantizeV2

Quantize o tensor de 'entrada' do tipo float para o tensor de 'saída' do tipo 'T'.

Resumo

[intervalo_min, intervalo_max] são flutuantes escalares que especificam o intervalo para os dados de 'entrada'. O atributo 'modo' controla exatamente quais cálculos são usados ​​para converter os valores flutuantes em seus equivalentes quantizados. O atributo 'round_mode' controla qual algoritmo de desempate de arredondamento é usado ao arredondar valores flutuantes para seus equivalentes quantizados.

No modo 'MIN_COMBINED', cada valor do tensor sofrerá o seguinte:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

aqui range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

Exemplo de modo MIN_COMBINED

Suponha que a entrada seja do tipo flutuante e tenha uma faixa possível de [0,0, 6,0] e o tipo de saída seja quint8 ([0, 255]). Os valores min_range e max_range devem ser especificados como 0,0 e 6,0. Quantizar de float para quint8 irá multiplicar cada valor da entrada por 255/6 e converter para quint8.

Se o tipo de saída for qint8 ([-128, 127]), a operação subtrairá adicionalmente cada valor por 128 antes da conversão, de modo que o intervalo de valores se alinhe com o intervalo de qint8.

Se o modo for 'MIN_FIRST', esta abordagem é usada:

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())

A maior diferença entre isso e MIN_COMBINED é que o intervalo mínimo é arredondado primeiro, antes de ser subtraído do valor arredondado. Com MIN_COMBINED, um pequeno viés é introduzido, onde iterações repetidas de quantização e desquantização irão introduzir um erro cada vez maior.

Exemplo de modo ESCALA

SCALED modo SCALED corresponde à abordagem de quantização usada em QuantizeAndDequantize{V2|V3} .

Se o modo for SCALED , não usamos a faixa completa do tipo de saída, escolhendo omitir o valor mais baixo possível para simetria (por exemplo, a faixa de saída é -127 a 127, não -128 a 127 para quantização de 8 bits com sinal), de modo que 0.0 mapeia para 0.

Primeiro encontramos a faixa de valores em nosso tensor. O intervalo que usamos é sempre centrado em 0, então encontramos m tal que

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

Nosso intervalo de tensor de entrada é então [-m, m] .

Em seguida, escolhemos nossos [min_fixed, max_fixed] quantização de ponto fixo, [min_fixed, max_fixed] . Se T for assinado, isso é

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

Caso contrário, se T não tiver sinal, a faixa de ponto fixo é

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

A partir disso, calculamos nosso fator de escala, s:

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

Agora podemos quantizar os elementos do nosso tensor:

result = round(input * s)

Uma coisa a se observar é que o operador pode escolher ajustar ligeiramente os valores mínimo e máximo solicitados durante o processo de quantização, portanto, você deve sempre usar as portas de saída como a faixa para cálculos adicionais. Por exemplo, se os valores mínimo e máximo solicitados forem quase iguais, eles serão separados por um pequeno valor épsilon para evitar que buffers quantizados malformados sejam criados. Caso contrário, você pode acabar com buffers onde todos os valores quantizados são mapeados para o mesmo valor flutuante, o que causa problemas para as operações que precisam realizar cálculos adicionais neles.

Argumentos:

• escopo: um objeto Scope
• intervalo_min: O valor escalar mínimo possivelmente produzido para a entrada.
• max_range: O valor escalar máximo possivelmente produzido para a entrada.

Retorna:

• Output saída: os dados quantizados produzidos a partir da entrada flutuante.
• Output output_min: O valor escalar mínimo real usado para a saída.
• Output output_max: O valor escalar máximo real usado para a saída.

Atributos públicos

Operation operation

::tensorflow::Output output

::tensorflow::Output output_max

::tensorflow::Output output_min

 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
)

Attrs Mode(
  StringPiece x
)

Attrs RoundMode(
  StringPiece x
)