tensorflow::ops::QuantizeV2

#include <array_ops.h>

Quantifier le tenseur « entrée » de type float en un tenseur « sortie » de type « T ».

Résumé

Les valeurs `min_range` et `max_range` sont des nombres flottants scalaires qui spécifient la plage des données d'entrée. L'attribut `mode` détermine précisément les calculs utilisés pour convertir les valeurs flottantes en leurs équivalents quantifiés. L'attribut `round_mode` détermine l'algorithme de départage utilisé pour arrondir les valeurs flottantes à leurs équivalents quantifiés.

En mode 'MIN_COMBINED', chaque valeur du tenseur subira le traitement suivant : 

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

Exemple de mode MIN_COMBINÉ

Supposons que l'entrée soit de type float et que sa plage de valeurs possibles soit [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 étant respectivement 0.0 et 6.0. La quantification de float vers quint8 multiplie chaque valeur de l'entrée par 255/6, puis effectue la conversion en quint8.

Si le type de sortie était qint8 ([-128, 127]), l'opération soustraira en plus chaque valeur de 128 avant la conversion, afin 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 principale différence avec MIN_COMBINED réside dans l'ordre d'arrondi de la valeur minimale : avant d'être soustraite de la valeur arrondie, cette dernière est modifiée. MIN_COMBINED introduit un léger biais, car les itérations répétées de quantification et de déquantification engendrent une erreur de plus en plus importante.

Exemple de mode STALED

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. Ce facteur est déterminé à partir min_range et max_range afin d'être aussi grand que possible pour que l'intervalle entre min_range et max_range soit représentable par des 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 facteur d'échelle 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, on comparerait -128/-10,0 = 12,8 à 127/9,0 = 14,11, et on définirait 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 dans la plage (-10, 9,921875) à (-128, 127).
 Le tenseur d'entrée peut maintenant être quantifié en limitant les valeurs à 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 valeurs ajustées min_range et max_range sont renvoyées comme sorties 2 et 3 de cette opération. Ces sorties doivent être utilisées comme plage pour tous les calculs ultérieurs.
 attribut narrow_range (booléen)
 Si cette condition est vraie, nous n'utilisons pas la valeur quantifiée minimale. Autrement dit, pour un entier 8 bits (int8), la sortie quantifiée sera limitée à l'intervalle -127..127 au lieu de l'intervalle complet -128..127. Ceci est prévu pour assurer la compatibilité avec certains moteurs d'inférence. (S'applique uniquement au mode SCALED)
 attribut axe (int)
 Un attribut axis optionnel permet de spécifier un index 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 =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 est de 0,01, mais il est fortement recommandé de la définir à 0 pour les nouvelles utilisations.
 Arguments :
  •  portée : un objet Scope
  •  min_range : 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 unidimensionnel dont la taille correspond à la dimension axis des tenseurs d’entrée et de sortie.
  •  max_range : 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 unidimensionnel dont la taille correspond à la dimension axis des tenseurs d’entrée et de sortie.
 Retours :
  •  Output : Les données quantifiées produites à partir de l’entrée flottante.
  •  Output : valeur minimale de la plage de quantification finale, utilisée pour écrêter les valeurs d'entrée avant leur mise à l'échelle et leur arrondi aux valeurs quantifiées. Si l'attribut axis est spécifié, il s'agira d'un tenseur unidimensionnel dont la taille correspond à la dimension axis des tenseurs d'entrée et de sortie.
  •  Output : valeur maximale de la plage de quantification finale, utilisée pour écrêter les valeurs d'entrée avant leur mise à l'échelle et leur arrondi aux valeurs quantifiées. Si l'attribut axis est spécifié, il s'agira d'un tenseur unidimensionnel dont la taille correspond à la dimension 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
 output
 output_max
 output_min
fonctions statiques publiques
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool x)
 RoundMode (StringPiece x)
 Structures
 tensorflow::ops::QuantizeV2::Attrs
 Définiteurs d'attributs optionnels 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 
 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
)
 fonctions statiques publiques 
 Axe 
Attrs Axis(
  int64 x
)
 Assurer la plage minimale 
Attrs EnsureMinimumRange(
  float x
)
 Mode 
Attrs Mode(
  StringPiece x
)
 NarrowRange 
Attrs NarrowRange(
  bool x
)
 Mode rond 
Attrs RoundMode(
  StringPiece x
)