fluxo tensor:: ops:: QuantizeV2

#include <array_ops.h>

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

Resumo

[min_range, max_range] são flutuadores escalares que especificam o intervalo para os dados de 'entrada'. O atributo 'mode' 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 passará pelo 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 float e tenha um intervalo 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. A quantização de float para quint8 multiplicará cada valor da entrada por 255/6 e será convertida em quint8.

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

Se o modo for 'MIN_FIRST', esta abordagem será 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 este 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 repetidas iterações de quantização e desquantização introduzirão um erro cada vez maior.

Exemplo de modo ESCALADO

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

Se o modo for SCALED , não usamos toda a faixa do tipo de saída, optando por 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 o intervalo 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 tensores de entrada é então [-m, m] .

A seguir, escolhemos nossos intervalos de quantização de ponto fixo, [min_fixed, max_fixed] . Se T estiver 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, o intervalo do 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 observar é que o operador pode optar por ajustar ligeiramente os valores mínimos e máximos solicitados durante o processo de quantização, portanto, você deve sempre usar as portas de saída como intervalo para cálculos posteriores. Por exemplo, se os valores mínimo e máximo solicitados forem próximos de iguais, eles serão separados por um pequeno valor épsilon para evitar a criação de buffers quantizados mal formados. 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 operações que precisam realizar cálculos adicionais sobre eles.

Argumentos:

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

Retorna:

  • Output : 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.

Construtores e Destruidores

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

Funções estáticas públicas

Mode (StringPiece x)
RoundMode (StringPiece x)

Estruturas

tensorflow:: ops:: QuantizeV2:: Attrs

Configuradores de atributos opcionais para QuantizeV2 .

Atributos públicos

operação 

Operation operation

saída 

::tensorflow::Output output

saída_max 

::tensorflow::Output output_max

saída_min 

::tensorflow::Output output_min

Funções públicas

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
)

Funções estáticas públicas

Modo 

Attrs Mode(
  StringPiece x
)

Modo redondo 

Attrs RoundMode(
  StringPiece x
)