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

tensorflow :: opérations :: Déquantifier

#include <array_ops.h>

Déquantifier le tenseur « d'entrée » dans un flotteur Tensor .

Résumé

[min_range, max_range] sont des flottants scalaires qui spécifient la plage pour la sortie. L'attribut 'mode' contrôle exactement quels calculs sont utilisés pour convertir les valeurs flottantes en leurs équivalents quantifiés.

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

if T == qint8: in[i] += (range(T) + 1)/ 2.0
out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
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

Si l'entrée provient d'un QuantizedRelu6 , le type de sortie est quint8 (plage de 0 à 255) mais la plage possible de QuantizedRelu6 est de 0 à 6. Les valeurs min_range et max_range sont donc 0,0 et 6,0. La déquantification sur quint8 prendra chaque valeur, transtypée en flottant et multipliée par 6 / 255. Notez que si le type quantifié est qint8, l'opération ajoutera en plus chaque valeur par 128 avant la transtypage.

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 = range / num_discrete_values
const double offset_input = static_cast(input) - lowest_quantized;
result = range_min + ((input - numeric_limits::min()) * range_scale)

Si le mode est SCALED , la déquantification est effectuée en multipliant chaque valeur d'entrée par un scaling_factor. (Ainsi, une entrée de 0 correspond toujours à 0,0).

Le scaling_factor est déterminé à partir de min_range , max_range et narrow_range d'une manière compatible avec QuantizeAndDequantize{V2|V3} et QuantizeV2 , en utilisant l'algorithme suivant:

  

  const int min_expected_T = std::numeric_limits::min() +
    (narrow_range ? 1 : 0);
  const int max_expected_T = std::numeric_limits::max();
  const float max_expected_T = std::numeric_limits::max();

  const float scale_factor =
    (std::numeric_limits::min() == 0) ? (max_range / max_expected_T)
                                         : std::max(min_range / min_expected_T,
                                                    max_range / max_expected_T);

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 : le tenseur de sortie.

Constructeurs et destructeurs

Dequantize (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range)
Dequantize (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, const Dequantize::Attrs & attrs)

Attributs publics

operation
output

Fonctions publiques

node () const
::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

Fonctions statiques publiques

Axis (int64 x)
Mode (StringPiece x)
NarrowRange (bool x)

Structs

tensorflow :: ops :: Dequantize :: Attrs

Définisseurs d' attributs facultatifs pour la déquantification .

Attributs publics

opération

Operation operation

production

::tensorflow::Output output

Fonctions publiques

Déquantifier

 Dequantize(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range
)

Déquantifier

 Dequantize(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  const Dequantize::Attrs & attrs
)

nœud

::tensorflow::Node * node() const 

operator :: tensorflow :: Input

 operator::tensorflow::Input() const 

operator :: tensorflow :: Output

 operator::tensorflow::Output() const 

Fonctions statiques publiques

Axe

Attrs Axis(
  int64 x
)

Mode

Attrs Mode(
  StringPiece x
)

Fourchette étroite

Attrs NarrowRange(
  bool x
)