tensorflow::ops::QuantizeV2

#include <array_ops.h>

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

Resumo

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

No modo 'MIN_COMBINED', cada valor do tensor passará pelo seguinte processo: 

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

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, respectivamente. A quantização de float para quint8 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, para que o intervalo de valores esteja alinhado com o intervalo de qint8.

Se o modo for 'MIN_FIRST', então esta abordagem será utilizada: 

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 principal diferença entre este método e o MIN_COMBINED é que, no MIN_COMBINED, o intervalo mínimo é arredondado primeiro, antes de ser subtraído do valor arredondado. Com o MIN_COMBINED, um pequeno viés é introduzido, pois iterações repetidas de quantização e desquantização geram 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 fator de escala. O fator de escala é determinado a partir de min_range e max_range para ser o maior possível, de forma 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 fator de escala 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 min_range = -10 e max_range = 9, compararíamos -128/-10,0 = 12,8 com 127/9,0 = 14,11 e definiríamos scaling_factor = 12,8. Nesse caso, min_range permaneceria -10, mas max_range seria ajustado para 127 / 12,8 = 9,921875.
 Assim, quantizaremos os valores de entrada no intervalo (-10, 9,921875) a (-128, 127).
 O tensor de entrada agora pode ser quantizado, limitando os valores ao intervalo de min_range a max_range e, em seguida, multiplicando-os pelo fator de escala, da seguinte forma: 
result = round(min(max_range, max(min_range, input)) * scale_factor)
 Os valores ajustados min_range e max_range são retornados como saídas 2 e 3 desta operação. Essas saídas devem ser usadas como intervalo para quaisquer cálculos subsequentes.
 atributo narrow_range (bool)
 Se verdadeiro, não usamos o valor quantizado mínimo. Ou seja, para int8, a saída quantizada seria restrita ao intervalo de -127 a 127, em vez do intervalo completo de -128 a 127. Isso é fornecido para compatibilidade com certos backends de inferência. (Aplica-se somente ao modo SCALED)
 atributo de eixo (int)
 Um atributo axis opcional pode especificar um índice de dimensão do tensor de entrada, de forma 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 serão definidos.
 Se axis = None, a quantização por tensor é realizada normalmente.
 atributo ensure_minimum_range (float)
 Garante que o intervalo mínimo de quantização seja pelo menos este valor. O valor padrão legado para isso é 0,01, mas é altamente recomendável defini-lo como 0 para novos usos.
 Argumentos:
  •  escopo: Um objeto de escopo
  •  min_range: O valor mínimo do intervalo 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 deve ser um tensor unidimensional cujo tamanho corresponda à dimensão do axis dos tensores de entrada e saída.
  •  `max_range`: O valor máximo do intervalo de quantização. Este valor pode ser ajustado pela operação dependendo de outros parâmetros. O valor ajustado é gravado em output_max . Se o atributo axis for especificado, este deve ser um tensor unidimensional cujo tamanho corresponda à dimensão do axis dos tensores de entrada e saída.
 Devoluções:
  •  Output : Os dados quantizados produzidos a partir da entrada de ponto flutuante.
  •  Output output_min: O valor mínimo final do intervalo de quantização, usado para limitar os valores de entrada antes de escalá-los e arredondá-los para valores quantizados. Se o atributo axis for especificado, este será um tensor unidimensional cujo tamanho corresponde à dimensão axis dos tensores de entrada e saída.
  •  Output output_max: O valor máximo do intervalo de quantização final, usado para limitar os valores de entrada antes de serem dimensionados e arredondados para valores quantizados. Se o atributo axis for especificado, este será um tensor unidimensional cujo tamanho corresponde à dimensão do axis dos tensores de entrada e saída. 
 Construtores e Destrutores
 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
 Definidores de atributos opcionais para QuantizeV2 .
 Atributos públicos 
 operação 
Operation operation
 saída 
::tensorflow::Output output
 saída_máxima 
::tensorflow::Output output_max
 saída_mínima 
::tensorflow::Output output_min
Funções públicas 
 QuantizarV2 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 QuantizarV2 
 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
)
 GarantirFaixaMínima 
Attrs EnsureMinimumRange(
  float x
)
 Modo 
Attrs Mode(
  StringPiece x
)
 Faixa estreita 
Attrs NarrowRange(
  bool x
)
 Modo redondo 
Attrs RoundMode(
  StringPiece x
)