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 , nous n'utilisons pas toute la plage du type de sortie, en choisissant d'éliminer la valeur la plus basse possible par 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 déterminons d'abord l'intervalle des valeurs de notre tenseur. Cet intervalle est toujours centré 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 intervalles de quantification à virgule fixe, [min_fixed, max_fixed] . Si T est signé, il s'agit de 

  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é, l'intervalle à 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)

Il convient de noter que l'opérateur peut ajuster légèrement les valeurs minimales et maximales demandées lors de la quantification. Il est donc impératif d'utiliser systématiquement les ports de sortie comme plage de valeurs pour les calculs ultérieurs. Par exemple, si les valeurs minimales et maximales demandées sont proches, elles seront séparées par une petite valeur epsilon afin d'éviter la création de tampons quantifiés incorrects. Dans le cas contraire, vous risquez de vous retrouver avec des tampons où toutes les valeurs quantifiées correspondent à la même valeur flottante, ce qui peut poser problème pour les opérations nécessitant des calculs ultérieurs.

Arguments :

  • portée : un objet Scope
  • min_range : La valeur scalaire minimale pouvant être produite pour l’entrée.
  • max_range : La valeur scalaire maximale pouvant être produite pour l’entrée.

Retours :

  • Output : Les données quantifiées produites à partir de l’entrée flottante.
  • Output output_min : La valeur scalaire minimale réelle utilisée pour la sortie.
  • Output output_max : La valeur scalaire maximale réelle utilisée pour la 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

Mode (StringPiece 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

Mode 

Attrs Mode(
  StringPiece x
)

Mode rond 

Attrs RoundMode(
  StringPiece x
)