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 , nous n'utilisons pas toute la plage du type de sortie, en choisissant d'élider la valeur la plus basse possible pour la symétrie (par exemple, la plage de sortie est de -127 à 127, et non de -128 à 127 pour une quantification signée sur 8 bits), de sorte que 0,0 correspond à 0.

Nous trouvons d’abord la plage de valeurs dans notre tenseur. La plage que nous utilisons est toujours centrée sur 0, nous trouvons donc m tel que

  m = max(abs(input_min), abs(input_max))

Notre plage de tenseurs d'entrée est alors [-m, m] .

Ensuite, nous choisissons nos compartiments de quantification à virgule fixe, [min_fixed, max_fixed] . Si T est signé, c'est

  num_bits = sizeof(T) * 8
  [min_fixed, max_fixed] =
      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]

Sinon, si T n'est pas signé, la plage en virgule fixe est

  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]

À partir de là, nous calculons notre facteur d’échelle, s :

  s = (max_fixed - min_fixed) / (2 * m)

Nous pouvons maintenant quantifier les éléments de notre tenseur :

result = round(input * s)

Une chose à surveiller est que l'opérateur peut choisir d'ajuster légèrement les valeurs minimales et maximales demandées pendant le processus de quantification, vous devez donc toujours utiliser les ports de sortie comme plage pour d'autres calculs. Par exemple, si les valeurs minimale et maximale demandées sont proches de l'égalité, elles seront séparées par une petite valeur epsilon pour éviter la création de tampons quantifiés mal formés. Sinon, vous pouvez vous retrouver avec des tampons dans lesquels toutes les valeurs quantifiées correspondent à la même valeur flottante, ce qui pose des problèmes pour les opérations qui doivent effectuer des calculs supplémentaires sur celles-ci.

Arguments :

• scope : un objet Scope
• min_range : la valeur scalaire minimale éventuellement produite pour l'entrée.
• max_range : la valeur scalaire maximale éventuellement produite pour l'entrée.

Retours :

• Sortie Output : les données quantifiées produites à partir de l'entrée flottante.
• Output output_min : valeur scalaire minimale réelle utilisée pour la sortie.
• Output output_max : valeur scalaire maximale réelle utilisée pour la sortie.

Attributs publics

Operation operation

::tensorflow::Output output

::tensorflow::Output output_max

::tensorflow::Output output_min

 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
)

Attrs Mode(
  StringPiece x
)

Attrs RoundMode(
  StringPiece x
)