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 valores flutuantes 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', então 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 , a quantização é realizada multiplicando cada valor de entrada por um scaling_factor. O scaling_factor é determinado a partir de min_range e max_range para ser o maior possível, de modo que o intervalo de min_range a max_range seja representável dentro de valores do 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);

 Em seguida, usamos o scale_factor para ajustar min_range e max_range da seguinte forma:
 
      min_range = min_T / scale_factor;
      max_range = max_T / scale_factor;

 por exemplo, se T = qint8 e inicialmente intervalo_min = -10 e intervalo_max = 9, compararíamos -128/-10,0 = 12,8 a 127/9,0 = 14,11 e definiríamos fator de escala = 12,8. Nesse caso, intervalo_min permaneceria -10, mas max_range seria ajustado para 127/12,8 = 9,921875
 Portanto, quantizaremos os valores de entrada no intervalo (-10, 9,921875) a (-128, 127).
 O tensor de entrada agora pode ser quantizado cortando valores no intervalo min_range a max_range e multiplicando por scale_factor da seguinte forma:
 
result = round(min(max_range, max(min_range, input)) * scale_factor)

 Os min_range e max_range ajustados são retornados como saídas 2 e 3 desta operação. Essas saídas devem ser usadas como intervalo para quaisquer cálculos adicionais.
 atributo intervalo_estreito (bool)
 Se for verdade, não usamos o valor quantizado mínimo. ou seja, para int8 a saída quantizada, ela seria restrita ao intervalo -127..127 em vez do intervalo completo -128..127. Isso é fornecido para compatibilidade com determinados back-ends de inferência. (Aplica-se apenas ao modo SCALED)
 atributo eixo (int)
 Um atributo axis opcional pode especificar um índice de dimensão do tensor de entrada, de modo que os intervalos de quantização sejam calculados e aplicados separadamente para cada fatia do tensor ao longo dessa dimensão. Isso é útil para quantização por canal.
 Se o eixo for especificado, min_range e max_range
 se axis =Nenhum, a quantização por tensor é realizada normalmente.
 atributo garantir_intervalo_mínimo (float)
 Garante que a faixa mínima de quantização seja pelo menos esse valor. O valor padrão herdado para isso é 0,01, mas é altamente recomendável defini-lo como 0 para novos usos.
 Argumentos:
  •  escopo: um objeto Escopo
  •  min_range: O valor mínimo da faixa de quantização. Este valor pode ser ajustado pelo operador dependendo de outros parâmetros. O valor ajustado é gravado em output_min . Se o atributo axis for especificado, este deverá ser um tensor 1-D cujo tamanho corresponda à dimensão axis dos tensores de entrada e saída.
  •  max_range: O valor máximo da faixa de quantização. Este valor pode ser ajustado pelo operador dependendo de outros parâmetros. O valor ajustado é gravado em output_max . Se o atributo axis for especificado, este deverá ser um tensor 1-D cujo tamanho corresponda à dimensão axis dos tensores de entrada e saída.
 Retorna:
  •  Output : Os dados quantizados produzidos a partir da entrada flutuante.
  •  Output output_min: O intervalo mínimo de quantização final, usado para cortar valores de entrada antes de redimensioná-los e arredondá-los para valores quantizados. Se o atributo axis for especificado, este será um tensor 1-D cujo tamanho corresponde à dimensão axis dos tensores de entrada e saída.
  •  Output output_max: O intervalo máximo de quantização final, usado para cortar valores de entrada antes de redimensioná-los e arredondá-los para valores quantizados. Se o atributo axis for especificado, este será um tensor 1-D cujo tamanho corresponde à dimensão axis dos tensores de entrada e 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
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool 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 
 Eixo 
 
Attrs Axis(
  int64 x
)
 GarantirFaixa Mínima 
 
Attrs EnsureMinimumRange(
  float x
)
 Modo 
 
Attrs Mode(
  StringPiece x
)
 Faixa Estreita 
 
Attrs NarrowRange(
  bool x
)
 Modo redondo
 
Attrs RoundMode(
  StringPiece x
)