Dequantize

classe finale pubblica Dequantize

Dequantizzare il tensore 'input' in un tensore float o bfloat16.

[min_range, max_range] sono float scalari che specificano l'intervallo per l'output. L'attributo 'mode' controlla esattamente quali calcoli vengono utilizzati per convertire i valori float nei loro equivalenti quantizzati.

Nella modalità 'MIN_COMBINED', ogni valore del tensore subirà quanto segue: 

if T == qint8: in[i] += (range(T) + 1)/ 2.0
 out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
qui `range(T) = numeric_limits ::max() - limiti_numerici ::min()`

Esempio di modalità MIN_COMBINED

Se l'input proviene da un QuantizedRelu6, il tipo di output è quint8 (intervallo 0-255) ma il possibile intervallo di QuantizedRelu6 è 0-6. I valori min_range e max_range sono quindi 0,0 e 6,0. Dequantizza su quint8 prenderà ogni valore, lo convertirà in float e lo moltiplicherà per 6/255. Tieni presente che se quantizedtype è qint8, l'operazione aggiungerà inoltre ogni valore per 128 prima dell'esecuzione del cast.

Se la modalità è "MIN_FIRST", viene utilizzato questo approccio: 

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)
Se la modalità è "SCALED", la dequantizzazione viene eseguita moltiplicando ciascun valore di input per un fattore di scala. (Pertanto un input pari a 0 corrisponde sempre a 0,0).

Il fattore di scala è determinato da `min_range`, `max_range` e `narrow_range` in modo compatibile con `QuantizeAndDequantize{V2|V3}` e `QuantizeV2`, utilizzando il seguente algoritmo: 

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

Classi nidificate

classe Dequantizza.Opzioni Attributi facoltativi per Dequantize

Costanti

Corda OP_NAME Il nome di questa operazione, come noto al motore principale di TensorFlow

Metodi pubblici

Uscita <U>
comeuscita ()
Restituisce l'handle simbolico del tensore.
Dequantize.Options statiche
asse (asse lungo)
statico <U estende TNumber > Dequantizza <U>
create ( Scope scope, Operando <? estende TType > input, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Class<U> dtype, Opzioni... opzioni)
Metodo factory per creare una classe che racchiude una nuova operazione Dequantize.
Dequantizzazione statica < TFloat32 >
create ( Scope scope, Operando <? estende TType > input, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Opzioni... opzioni)
Metodo factory per creare una classe che racchiude una nuova operazione Dequantize utilizzando i tipi di output predefiniti.
Dequantize.Options statiche
modalità (modalità stringa)
Dequantize.Options statiche
narrowRange (Booleano narrowRange)
Uscita <U>
produzione ()

Metodi ereditati

Costanti

Stringa finale statica pubblica OP_NAME

Il nome di questa operazione, come noto al motore principale di TensorFlow

Valore costante: "Dequantizza"

Metodi pubblici

Uscita pubblica <U> asOutput ()

Restituisce l'handle simbolico del tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

asse Dequantize.Options pubblico statico (asse lungo)

public static Dequantize <U> create ( Scope scope, Operando <? estende TType > input, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Class<U> dtype, Opzioni... opzioni)

Metodo factory per creare una classe che racchiude una nuova operazione Dequantize.

Parametri
scopo ambito attuale
minRange Il valore scalare minimo eventualmente prodotto per l'input.
maxRange Il valore scalare massimo possibilmente prodotto per l'input.
dtype Tipo del tensore di uscita. Attualmente Dequantize supporta float e bfloat16. Se 'dtype' è 'bfloat16', supporta solo la modalità 'MIN_COMBINED'.
opzioni trasporta valori di attributi opzionali
ritorna
  • una nuova istanza di Dequantize

public static Dequantize < TFloat32 > create ( Scope scope, Operando <? estende TType > input, Operando < TFloat32 > minRange, Operando < TFloat32 > maxRange, Opzioni... opzioni)

Metodo factory per creare una classe che racchiude una nuova operazione Dequantize utilizzando i tipi di output predefiniti.

Parametri
scopo ambito attuale
minRange Il valore scalare minimo eventualmente prodotto per l'input.
maxRange Il valore scalare massimo possibilmente prodotto per l'input.
opzioni trasporta valori di attributi opzionali
ritorna
  • una nuova istanza di Dequantize

modalità pubblica statica Dequantize.Options (modalità String)

public static Dequantize.Options narrowRange (Boolean narrowRange)

Uscita pubblica <U> uscita ()