flux tensoriel : : opérations : : QuantifierV2

Quantifiez le tenseur « d'entrée » de type float en tenseur « de sortie » de type « T ».

Résumé

[min_range, max_range] sont des flottants scalaires qui spécifient la plage des données « d'entrée ». L'attribut 'mode' contrôle exactement quels calculs sont utilisés pour convertir les valeurs flottantes en leurs équivalents quantifiés. L'attribut 'round_mode' contrôle quel algorithme de départage est utilisé lors de l'arrondi des valeurs flottantes à leurs équivalents quantifiés.

En mode 'MIN_COMBINED', chaque valeur du tenseur subira les opérations suivantes :

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

ici range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

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

La plus grande différence entre ceci et MIN_COMBINED est que la plage minimale est d'abord arrondie, avant d'être soustraite de la valeur arrondie. Avec MIN_COMBINED, un petit biais est introduit où des itérations répétées de quantification et de déquantification introduiront une erreur de plus en plus grande.

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::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);
 Nous utilisons ensuite le scale_factor pour ajuster min_range et max_range comme suit :
 
      min_range = min_T / scale_factor;
      max_range = max_T / scale_factor;
 Par exemple, si T = qint8, et initialement min_range = -10 et max_range = 9, nous comparerions -128/-10,0 = 12,8 à 127/9,0 = 14,11, et définirions scaling_factor = 12,8. Dans ce cas, min_range resterait -10, mais max_range serait ajusté à 127/12,8 = 9,921875
 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)
 Les min_range et max_range ajustés sont renvoyés comme sorties 2 et 3 de cette opération. Ces sorties doivent être utilisées comme plage pour tout calcul ultérieur.
 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 axis facultatif peut spécifier un indice de dimension du tenseur d'entrée, de sorte que les plages de quantification soient 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 = Aucun, 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.
 Arguments:
 scope : un objet Scope
 min_range : La valeur minimale de la plage de quantification. Cette valeur peut être ajustée par l'opérateur en fonction d'autres paramètres. La valeur ajustée est écrite dans output_min . Si l'attribut axis est spécifié, il doit s'agir d'un tenseur 1D dont la taille correspond à la dimension de l' axis des tenseurs d'entrée et de sortie.
 max_range : La valeur maximale de la plage de quantification. Cette valeur peut être ajustée par l'opérateur en fonction d'autres paramètres. La valeur ajustée est écrite dans output_max . Si l'attribut axis est spécifié, il doit s'agir d'un tenseur 1D dont la taille correspond à la dimension de l' axis des tenseurs d'entrée et de sortie.
 Retour:
 Sortie Output : les données quantifiées produites à partir de l'entrée flottante.
 Output output_min : le minimum de la plage de quantification finale, utilisé pour découper les valeurs d'entrée avant de les mettre à l'échelle et de les arrondir aux valeurs quantifiées. Si l'attribut axis est spécifié, il s'agira d'un tenseur 1D dont la taille correspond à la dimension de axis des tenseurs d'entrée et de sortie.
 Output output_max : le maximum de la plage de quantification finale, utilisé pour découper les valeurs d'entrée avant de les mettre à l'échelle et de les arrondir aux valeurs quantifiées. Si l'attribut axis est spécifié, il s'agira d'un tenseur 1D dont la taille correspond à la dimension de axis des tenseurs d'entrée et de sortie. 
 Constructeurs et Destructeurs
 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)
 
 Attributs publics
 operation
 Operation
 output
 :: tensorflow::Output
 output_max
 :: tensorflow::Output
 output_min
 :: tensorflow::Output
 
Fonctions statiques publiques
 Axis (int64 x)
 Attrs
 EnsureMinimumRange (float x)
 Attrs
 Mode (StringPiece x)
 Attrs
 NarrowRange (bool x)
 Attrs
 RoundMode (StringPiece x)
 Attrs
 
 Structures
 tensorflow :: ops :: QuantizeV2 :: Attrs
 Setters d'attributs facultatifs pour QuantizeV2 .
 Attributs publics 
 opération
 
Operation operation
 
 sortir
 
::tensorflow::Output output
 
 sortie_max
 
::tensorflow::Output output_max
 
 sortie_min
 
::tensorflow::Output output_min
 Fonctions publiques 
 QuantifierV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 
 QuantifierV2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)
 Fonctions statiques publiques 
 Axe
 
Attrs Axis(
  int64 x
)
 
 Assurer la plage minimale
 
Attrs EnsureMinimumRange(
  float x
)
 
 Mode
 
Attrs Mode(
  StringPiece x
)
 
 Fourchette étroite
 
Attrs NarrowRange(
  bool x
)
 
 Mode rond
 
Attrs RoundMode(
  StringPiece x
)