Dequantize

classe finale publique Déquantifier

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

[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 éléments suivants : 

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() - limites_numériques ::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<double>(input) - lowest_quantized;
 result = range_min + ((input - numeric_limits<T>::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 facteur d'échelle 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<T>::min() +
     (narrow_range ? 1 : 0);
   const int max_expected_T = std::numeric_limits<T>::max();
   const float max_expected_T = std::numeric_limits<float>::max();
 
   const float scale_factor =
     (std::numeric_limits<T>::min() == 0) ? (max_range / max_expected_T)
                                          : std::max(min_range / min_expected_T,
                                                     max_range / max_expected_T);

Classes imbriquées

classe Déquantifier.Options Attributs facultatifs pour Dequantize

Constantes

Chaîne OP_NAME Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Méthodes publiques

Sortie <U>
comme Sortie ()
Renvoie le handle symbolique du tenseur.
Déquantification statique.Options
axe (axe long)
statique <U étend TNumber > Déquantifier <U>
créer ( Scope scope, Operand <? extends TType > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Class<U> dtype, Options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération Dequantize.
Déquantification statique < TFloat32 >
créer ( Scope scope, Operand <? extends TType > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération Dequantize à l'aide des types de sortie par défaut.
Déquantification statique.Options
mode (mode chaîne)
Déquantification statique.Options
étroitRange (booléen étroitRange)
Sortie <U>
sortir ()

Méthodes héritées

Constantes

chaîne finale statique publique OP_NAME

Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Valeur constante : "Déquantiser"

Méthodes publiques

sortie publique <U> asOutput ()

Renvoie le handle symbolique du tenseur.

Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.

Axe public static Dequantize.Options (axe long)

public static Dequantize <U> create ( Scope scope, Operand <? extends TType > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Class<U> dtype, Options... options)

Méthode d'usine pour créer une classe encapsulant une nouvelle opération Dequantize.

Paramètres
portée portée actuelle
plagemin La valeur scalaire minimale éventuellement produite pour l'entrée.
plagemax La valeur scalaire maximale éventuellement produite pour l'entrée.
type 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'.
choix porte des valeurs d'attributs facultatifs
Retour
  • une nouvelle instance de Dequantize

public static Dequantize < TFloat32 > créer ( Scope scope, Operand <? extends TType > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Options... options)

Méthode d'usine pour créer une classe encapsulant une nouvelle opération Dequantize à l'aide des types de sortie par défaut.

Paramètres
portée portée actuelle
plagemin La valeur scalaire minimale éventuellement produite pour l'entrée.
plagemax La valeur scalaire maximale éventuellement produite pour l'entrée.
choix porte des valeurs d'attributs facultatifs
Retour
  • une nouvelle instance de Dequantize

Mode Dequantize.Options statique public (mode String)

public static Dequantize.Options étroitRange (booléen étroitRange)

Sortie publique Sortie <U> ()