Cette page a été traduite par l'API Cloud Translation.
Switch to English

tensorflow :: ops :: déquantifier

#include <array_ops.h>

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

Résumé

[Min_range, max_range] sont des flotteurs scalaires qui spécifient la plage de la sortie. Les commandes d'attribut « mode » exactement quels calculs sont utilisés pour convertir les valeurs flottantes à leurs équivalents quantifiées.

En mode « MIN_COMBINED », chaque valeur du tenseur sera soumis à 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()

MIN_COMBINED Exemple de mode

Si l'entrée provient d'un QuantizedRelu6 , le type de sortie est quint8 (gamme de 0-255) , mais la gamme possible de QuantizedRelu6 est 0-6. Les valeurs de min_range et max_range sont donc 0,0 et 6,0. Déquantifier sur quint8 prendra chaque valeur, la distribution à flotteur, et multiplier par 6 / 255. Notez que si quantizedtype est qint8, l'opération sera en outre ajouter chaque valeur de 128 avant la coulée.

Si le mode est « MIN_FIRST », 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 , déquantification est effectuée en multipliant chaque valeur d'entrée par un scaling_factor. (Ainsi, une entrée de 0 cartes toujours à 0.0).

Le scaling_factor est déterminé à partir min_range , max_range et narrow_range d'une manière qui est 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:

  • portée: A Portée objet
  • min_range: La valeur scalaire minimum éventuellement produite pour l'entrée.
  • max_range: La valeur scalaire maximale peut-être produite pour l'entrée.

Les attributs facultatifs (voir Attrs ):

  • DTYPE: Type du tenseur de sortie. À l' heure actuelle déquantifier soutient flotteur et bfloat16. Si 'DTYPE' est 'bfloat16', il ne le mode de soutien 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
output

Les fonctions publiques

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

fonctions statiques publiques

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

struct

tensorflow :: :: ops déquantifier :: ATTRS

Setters d'attributs en option pour déquantifier .

attributs publics

opération

 Operation operation

production

:: tensorflow::Output output

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

DTYPE

 Attrs Dtype(
  DataType x
)

Mode

 Attrs Mode(
  StringPiece x
)

Fourchette étroite

 Attrs NarrowRange(
  bool x
)