Quantize

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<T>::min()
 quantized = max(quantized, numeric_limits<T>::min())
 quantized = min(quantized, numeric_limits<T>::max())
 

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 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<T>::min();
   const int max_T = std::numeric_limits<T>::max();
   const float max_float = std::numeric_limits<float>::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);
 

min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 

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)
 

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 opcional `axis` 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`=None, 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.