Quantize

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

Exemplo de modo ESCALA

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

Se o modo for `ESCALADA`, a quantização é realizada multiplicando cada valor de entrada por um fator_escala. O scaling_factor é determinada a partir `` min_range` e max_range` a ser tão grande quanto possível de modo a que a gama de min_range` `a` max_range` é representável dentro de valores de 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 podem agora ser quantificados por grampeamento valores para a gama `` min_range` para max_range`, multiplicando em seguida por fator_escala como se segue:

result = round(min(max_range, max(min_range, input)) * scale_factor)
 

Atributo gama_estrita (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 do intervalo total -128..127. Isso é fornecido para compatibilidade com determinados back-ends de inferência. (Aplica-se apenas ao modo ESCALA)

atributo do 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 `eixo` = Nenhum, a quantização por tensor é realizada 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.