Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

tensorflow :: opérations :: QuantizeV2

#include <array_ops.h>

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 , la quantification est effectuée en multipliant chaque valeur d'entrée par un scaling_factor. Le scaling_factor 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 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 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éfinir 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 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 sont renvoyées en tant que sorties 2 et 3 de cette opération. Ces sorties doivent être utilisées comme plage pour tout autre calcul.

Attribut narrow_range (booléen)

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 la compatibilité avec certains backends d'inférence. (S'applique uniquement au mode SCALED)

attribut axis (int)

Un attribut d' axis facultatif peut spécifier un indice de dimension du tenseur d'entrée, de sorte que les plages de quantification seront 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 axis 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 correspond au moins à cette valeur. La valeur par défaut héritée pour cela est 0,01, mais il est fortement recommandé de la définir sur 0 pour les nouvelles utilisations.

Arguments:

  • scope: un objet Scope
  • min_range: valeur minimale de la plage de quantification. Cette valeur peut être ajustée par l'op 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 1-D dont la taille correspond à la dimension d' 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 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 1-D dont la taille correspond à la dimension d' axis des tenseurs d'entrée et de sortie.

Retour:

  • Output sortie: Les données quantifiées produites à partir de l'entrée flottante.
  • Output output_min: La plage de quantification finale minimale, utilisée 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é, ce sera un tenseur 1-D dont la taille correspond à la dimension d' axis des tenseurs d'entrée et de sortie.
  • Output output_max: La plage de quantification finale maximale, utilisée 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é, ce sera un tenseur 1-D dont la taille correspond à la dimension d' 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)

Structs

tensorflow :: ops :: QuantizeV2 :: Attrs

Définisseurs d'attributs facultatifs pour QuantizeV2 .

Attributs publics

opération

Operation operation

production

::tensorflow::Output output

output_max

::tensorflow::Output output_max

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

EnsureMinimumRange

Attrs EnsureMinimumRange(
  float x
)

Mode

Attrs Mode(
  StringPiece x
)

Fourchette étroite

Attrs NarrowRange(
  bool x
)

RoundMode

Attrs RoundMode(
  StringPiece x
)