tensoreflusso:: ops:: Quantizza V2

#include <array_ops.h>

Quantizza il tensore 'input' di tipo float nel tensore 'output' di tipo 'T'.

Riepilogo

[min_range, max_range] sono float scalari che specificano l'intervallo per i dati di "input". L'attributo 'mode' controlla esattamente quali calcoli vengono utilizzati per convertire i valori float nei loro equivalenti quantizzati. L'attributo 'round_mode' controlla quale algoritmo di arrotondamento viene utilizzato quando si arrotondano i valori float ai loro equivalenti quantizzati.

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

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

qui range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

Esempio di modalità MIN_COMBINED

Supponiamo che l'input sia di tipo float e abbia un intervallo possibile di [0.0, 6.0] e che il tipo di output sia quint8 ([0, 255]). I valori min_range e max_range devono essere specificati come 0,0 e 6,0. La quantizzazione da float a quint8 moltiplicherà ciascun valore dell'input per 255/6 e lo trasformerà in quint8.

Se il tipo di output era qint8 ([-128, 127]), l'operazione sottrarrà inoltre ogni valore di 128 prima della conversione, in modo che l'intervallo di valori si allinei con l'intervallo di qint8.

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 = num_discrete_values / range
quantized = round(input * range_scale) - round(range_min * range_scale) +
  numeric_limits::min()
quantized = max(quantized, numeric_limits::min())
quantized = min(quantized, numeric_limits::max())

La differenza più grande tra questo e MIN_COMBINED è che l'intervallo minimo viene arrotondato per primo, prima di essere sottratto dal valore arrotondato. Con MIN_COMBINED, viene introdotto un piccolo bias in cui ripetute iterazioni di quantizzazione e dequantizzazione introdurranno un errore sempre più grande.

Esempio della modalità SCALA

La modalità SCALED corrisponde all'approccio di quantizzazione utilizzato in QuantizeAndDequantize{V2|V3} .

Se la modalità è SCALED , non utilizziamo l'intero intervallo del tipo di output, scegliendo di elidere il valore più basso possibile per la simmetria (ad esempio, l'intervallo di output è compreso tra -127 e 127, non tra -128 e 127 per la quantizzazione a 8 bit con segno), in modo che 0.0 corrisponda a 0.

Per prima cosa troviamo l'intervallo di valori nel nostro tensore. L'intervallo che usiamo è sempre centrato su 0, quindi troviamo m tale che

  m = max(abs(input_min), abs(input_max))

Il nostro intervallo del tensore di input è quindi [-m, m] .

Successivamente, scegliamo i nostri bucket di quantizzazione a virgola fissa, [min_fixed, max_fixed] . Se T è firmato, questo lo è

  num_bits = sizeof(T) * 8
  [min_fixed, max_fixed] =
      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]

Altrimenti, se T non ha segno, lo è l'intervallo in virgola fissa

  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]

Da questo calcoliamo il nostro fattore di scala, s:

  s = (max_fixed - min_fixed) / (2 * m)

Ora possiamo quantizzare gli elementi del nostro tensore:

result = round(input * s)

Una cosa a cui prestare attenzione è che l'operatore può scegliere di regolare leggermente i valori minimo e massimo richiesti durante il processo di quantizzazione, quindi dovresti sempre utilizzare le porte di output come intervallo per ulteriori calcoli. Ad esempio, se i valori minimo e massimo richiesti sono quasi uguali, verranno separati da un piccolo valore epsilon per impedire la creazione di buffer quantizzati con formato errato. Altrimenti, ci si può ritrovare con buffer in cui tutti i valori quantizzati vengono mappati allo stesso valore float, il che causa problemi alle operazioni che devono eseguire ulteriori calcoli su di essi.

Argomenti:

  • scope: un oggetto Scope
  • min_range: il valore scalare minimo eventualmente prodotto per l'input.
  • max_range: il valore scalare massimo possibilmente prodotto per l'input.

Resi:

  • Output output: i dati quantizzati prodotti dall'input float.
  • Output output_min: il valore scalare minimo effettivo utilizzato per l'output.
  • Output output_max: il valore scalare massimo effettivo utilizzato per l'output.

Costruttori e distruttori

QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T)
QuantizeV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input input, :: tensorflow::Input min_range, :: tensorflow::Input max_range, DataType T, const QuantizeV2::Attrs & attrs)

Attributi pubblici

operation
output
output_max
output_min

Funzioni pubbliche statiche

Mode (StringPiece x)
RoundMode (StringPiece x)

Strutture

tensorflow:: ops:: QuantizeV2:: Attrs

Setter di attributi opzionali per QuantizeV2 .

Attributi pubblici

operazione

Operation operation

produzione

::tensorflow::Output output

uscita_max

::tensorflow::Output output_max

uscita_min

::tensorflow::Output output_min

Funzioni pubbliche

Quantizza V2

 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)

Quantizza V2

 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)

Funzioni pubbliche statiche

Modalità

Attrs Mode(
  StringPiece x
)

Modalità rotonda

Attrs RoundMode(
  StringPiece x
)