Quantize

Exemple de mode MIN_COMBINED

Supposons que l'entrée soit de type float et ait une plage possible de [0.0, 6.0] et que le type de sortie soit quint8 ([0, 255]). Les valeurs min_range et max_range doivent être spécifiées comme 0,0 et 6,0. La quantification de float à quint8 multipliera chaque valeur de l'entrée par 255/6 et sera convertie en quint8.

Si le type de sortie était qint8 ([-128, 127]), l'opération soustraira en outre chaque valeur de 128 avant la conversion, de sorte que la plage de valeurs s'aligne sur la plage de qint8.

Si le mode est 'MIN_FIRST', alors cette approche est utilisée :

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

Mode ÉCHELLE Exemple

Le mode `SCALED` correspond à l'approche de quantification utilisée dans `QuantizeAndDequantize{V2|V3}`.

Si le mode est « SCALED », la quantification est effectuée en multipliant chaque valeur d'entrée par un facteur d'échelle. Le facteur d'échelle est déterminé à partir de `min_range` et `max_range` pour être aussi grand que possible de sorte que la plage de `min_range` à `max_range` soit représentable dans les valeurs de type 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;
 

Nous allons donc quantifier les valeurs d'entrée comprises entre (-10, 9,921875) et (-128, 127).

Le tenseur d'entrée peut maintenant être quantifié en découpant les valeurs dans la plage « min_range » à « max_range », puis en multipliant par scale_factor comme suit :

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

Attribut étroit_range (bool)

Si c’est vrai, nous n’utilisons pas la valeur quantifiée minimale. c'est-à-dire que pour int8 la sortie quantifiée, elle serait limitée à la plage -127..127 au lieu de la plage complète -128..127. Ceci est fourni pour des raisons de compatibilité avec certains backends d’inférence. (S'applique uniquement au mode SCALED)

attribut axe (int)

Un attribut facultatif « axis » peut spécifier un indice de dimension du tenseur d'entrée, de telle sorte que les plages de quantification seront calculées et appliquées séparément pour chaque tranche du tenseur le long de cette dimension. Ceci est utile pour la quantification par canal.

Si l'axe est spécifié, min_range et max_range

si `axis`=None, la quantification par tenseur est effectuée normalement.

Attribut Ensure_minimum_range (float)

Garantit que la plage de quantification minimale est au moins égale à cette valeur. La valeur par défaut héritée est 0,01, mais il est fortement suggéré de la définir sur 0 pour les nouvelles utilisations.