tensorflow::ops::QuantizeV2

#include <array_ops.h>

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

Riepilogo

[min_range, max_range] sono valori scalari in virgola mobile che specificano l'intervallo per i dati di 'input'. L'attributo 'mode' controlla esattamente quali calcoli vengono utilizzati per convertire i valori in virgola mobile nei loro equivalenti quantizzati. L'attributo 'round_mode' controlla quale algoritmo di arrotondamento per la risoluzione dei casi di parità viene utilizzato quando si arrotondano i valori in virgola mobile ai loro equivalenti quantizzati.

Nella modalità 'MIN_COMBINED', ogni valore del tensore verrà sottoposto alle seguenti operazioni: 

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

Esempio di modalità MIN_COMBINED

Si supponga che l'input sia di tipo float con un intervallo possibile di [0.0, 6.0] e che il tipo di output sia quint8 ([0, 255]). I valori di 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 convertirà in quint8.

Se il tipo di output era qint8 ([-128, 127]), l'operazione sottrarrà inoltre 128 da ciascun valore 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 principale tra questo e MIN_COMBINED è che l'intervallo minimo viene prima arrotondato, prima di essere sottratto dal valore arrotondato. Con MIN_COMBINED, viene introdotto un piccolo errore sistematico, per cui ripetute iterazioni di quantizzazione e dequantizzazione introdurranno un errore sempre maggiore.

Esempio di modalità SCALED

La 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 omettere il valore più basso possibile per 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 venga mappato 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 tensoriale di input è quindi [-m, m] .

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

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

Altrimenti, se T non è segnato, l'intervallo a virgola fissa è 

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

Da ciò 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)

Un aspetto da tenere presente è che l'operatore potrebbe decidere di modificare leggermente i valori minimi e massimi richiesti durante il processo di quantizzazione, quindi è sempre consigliabile utilizzare le porte di output come intervallo per i calcoli successivi. Ad esempio, se i valori minimi e massimi richiesti sono molto vicini, verranno separati da un piccolo valore epsilon per evitare la creazione di buffer quantizzati non validi. In caso contrario, si potrebbero ottenere buffer in cui tutti i valori quantizzati corrispondono allo stesso valore float, causando problemi alle operazioni che devono eseguire ulteriori calcoli su di essi.

Argomentazioni:

  • ambito: un oggetto Scope
  • min_range: Il valore scalare minimo che può essere prodotto per l'input.
  • max_range: Il valore scalare massimo che può essere 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 statiche pubbliche

Mode (StringPiece x)
RoundMode (StringPiece x)

Strutture

tensorflow::ops::QuantizeV2::Attrs

Impostazioni opzionali degli attributi 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
)

Modalità rotonda 

Attrs RoundMode(
  StringPiece x
)