flux tensoriel : : opérations : : Déquantifier

#include <array_ops.h>

Déquantifiez le tenseur « d'entrée » en un float ou un bfloat16 Tensor .

Résumé

[min_range, max_range] sont des flottants scalaires qui spécifient la plage de 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 les opérations suivantes :

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. Dequantize sur quint8 prendra chaque valeur, convertie en float et multipliée par 6/255. Notez que si quantizedtype est qint8, l'opération ajoutera en plus chaque valeur par 128 avant la conversion.

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 facteur d'échelle. (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 , à l'aide de 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.
 Attributs facultatifs (voir Attrs ) :
 dtype : Type du tenseur de sortie. Actuellement , Dequantize prend en charge float et bfloat16. Si 'dtype' est 'bfloat16', il ne prend en charge que le mode 'MIN_COMBINED'.
 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
 Operation
 output
 :: tensorflow::Output
 
 Fonctions publiques
 node () const
 ::tensorflow::Node *
 operator::tensorflow::Input () const
 operator::tensorflow::Output () const
 
Fonctions statiques publiques
 Axis (int64 x)
 Attrs
 Dtype (DataType x)
 Attrs
 Mode (StringPiece x)
 Attrs
 NarrowRange (bool x)
 Attrs
 
 Structures
 tensorflow : ops : Déquantifier : Attrs
 Setters d'attributs facultatifs pour Dequantize .
 Attributs publics 
 opération
 
Operation operation
 
 sortir
 
::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 
 
 opérateur :: tensorflow :: Entrée
 
 operator::tensorflow::Input() const 
 
 opérateur :: tensorflow :: Sortie
 
 operator::tensorflow::Output() const 
 Fonctions statiques publiques 
 Axe
 
Attrs Axis(
  int64 x
)
 
 Type D
 
Attrs Dtype(
  DataType x
)
 
 Mode
 
Attrs Mode(
  StringPiece x
)
 
 Fourchette étroite
 
Attrs NarrowRange(
  bool x
)