tensorflow :: opérations :: QuantizeV2

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

Résumé

[min_range, max_range] sont des flottants scalaires qui spécifient la plage pour les 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 d'arrondi de départage est utilisé pour arrondir les valeurs flottantes à leurs équivalents quantifiés.

En mode 'MIN_COMBINED', chaque valeur du tenseur subira ce qui suit:

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 est de type float et a une plage possible de [0,0, 6,0] et que le type de sortie est 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 en quint8 multipliera chaque valeur de l'entrée par 255/6 et transtypera 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 arrondie en premier, 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.

Exemple de mode SCALED

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

Si le mode est SCALED , nous n'utilisons pas la plage complète 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 la quantification 8 bits signée) 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, donc nous trouvons m tel que

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

Notre gamme de tenseur d'entrée est alors [-m, m] .

Ensuite, nous choisissons nos [min_fixed, max_fixed] quantification en 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 minimum et maximum demandées pendant le processus de quantification, vous devez donc toujours utiliser les ports de sortie comme plage pour les calculs ultérieurs. Par exemple, si les valeurs minimum et maximum demandées sont proches de l'égalité, elles seront séparées par une petite valeur epsilon pour empêcher la création de tampons quantifiés mal formés. Sinon, vous pouvez vous retrouver avec des tampons où 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 eux.

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.

Retour:

• Output sortie: 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
)