Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

tensorflow :: ops :: QuantizeV2

#include <array_ops.h>

Quantizza il tensore di "input" di tipo float sul tensore di "output" di tipo "T".

Sommario

[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.

In modalità 'MIN_COMBINATO', ogni 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 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à ogni valore dell'input per 255/6 e convertirà in quint8.

Se il tipo di output era qint8 ([-128, 127]), l'operazione sottrarrà inoltre ciascun valore per 128 prima del cast, 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 di modalità SCALED

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

Se la modalità è SCALED , non utilizziamo l'intera gamma del tipo di output, scegliendo di elide il valore più basso possibile per la simmetria (ad esempio, l'intervallo di output è da -127 a 127, non da -128 a 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 è

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

Altrimenti, se T è senza segno, l'intervallo di 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 è necessario utilizzare sempre le porte di uscita come intervallo per ulteriori calcoli. Ad esempio, se i valori minimo e massimo richiesti sono quasi uguali, saranno separati da un piccolo valore epsilon per impedire la creazione di buffer quantizzati mal formati. Altrimenti, puoi ritrovarti con buffer in cui tutti i valori quantizzati mappano allo stesso valore float, il che causa problemi per le operazioni che devono eseguire ulteriori calcoli su di essi.

Argomenti:

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

Ritorna:

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

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 statiche pubbliche

Mode (StringPiece x)
RoundMode (StringPiece x)

Structs

tensorflow :: ops :: QuantizeV2 :: Attrs

Setter di attributi opzionali per QuantizeV2 .

Attributi pubblici

operazione

Operation operation

produzione

::tensorflow::Output output

output_max

::tensorflow::Output output_max

output_min

::tensorflow::Output output_min

Funzioni pubbliche

QuantizeV2

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

QuantizeV2

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

Funzioni statiche pubbliche

Modalità

Attrs Mode(
  StringPiece x
)

RoundMode

Attrs RoundMode(
  StringPiece x
)