tensorflow :: ops :: QuantizeV2

#include <array_ops.h>

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 , 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 forma que o intervalo de min_range a max_range seja representável em 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 scale_factor para ajustar min_range e max_range da seguinte maneira:
 
      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 a 127 / 9,0 = 14,11 e definir scaling_factor = 12,8 Neste caso, min_range permaneceria -10, mas max_range seria ajustado para 127 / 12,8 = 9,921875
 Portanto, quantificaremos os valores de entrada no intervalo (-10, 9,921875) a (-128, 127).
 O tensor de entrada agora pode ser quantizado min_range valores para o intervalo min_range para max_range , em seguida, multiplicando por scale_factor da seguinte maneira:
 
result = round(min(max_range, max(min_range, input)) * scale_factor)

 O ajustada 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 adicionais.
 Atributo intervalo_estrito (bool)
 Se verdadeiro, não usamos o valor mínimo quantizado. ou seja, para int8 a saída quantizada, seria restrito ao intervalo -127..127 em vez de ao intervalo total -128..127. Isso é fornecido para compatibilidade com certos back-ends de inferência. (Aplica-se apenas ao modo ESCALA)
 atributo eixo (int)
 Um atributo de 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 é executada normalmente.
 atributo garantir_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 Scope
  •  intervalo_min: o valor mínimo do intervalo de quantização. Este valor pode ser ajustado pelo op dependendo de outros parâmetros. O valor ajustado é gravado em output_min . Se o atributo do axis for especificado, deve ser um tensor 1-D cujo tamanho corresponda à dimensão do axis dos tensores de entrada e saída.
  •  intervalo_max: o valor máximo do intervalo de quantização. Este valor pode ser ajustado pelo op dependendo de outros parâmetros. O valor ajustado é escrito em output_max . Se o atributo do axis for especificado, deve ser um tensor 1-D cujo tamanho corresponda à dimensão do axis dos tensores de entrada e saída.
 Retorna:
  •  Output saída: os dados quantizados produzidos a partir da entrada flutuante.
  •  Output output_min: O mínimo do intervalo de quantização final, usado para cortar valores de entrada antes de escaloná-los e arredondá-los para valores quantizados. Se o atributo do axis for especificado, este será um tensor 1-D cujo tamanho corresponde à dimensão do axis dos tensores de entrada e saída.
  •  Output output_max: O máximo do intervalo de quantização final, usado para cortar valores de entrada antes de escaloná-los e arredondá-los para valores quantizados. Se o atributo do axis for especificado, este será um tensor 1-D cujo tamanho corresponde à dimensão do 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) 
 Structs
 tensorflow :: ops :: QuantizeV2 :: Attrs
 Configuradores de atributos opcionais para QuantizeV2 .
 Atributos públicos 
 Operação
 
Operation operation
 
 resultado
 
::tensorflow::Output output
 
 output_max
 
::tensorflow::Output output_max
 
 output_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
)
 
 GarantirMinimumRange
 
Attrs EnsureMinimumRange(
  float x
)
 
 Modo
 
Attrs Mode(
  StringPiece x
)
 
 Curto alcance
 
Attrs NarrowRange(
  bool x
)
 
 RoundMode
 
Attrs RoundMode(
  StringPiece x
)