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 , la quantizzazione viene eseguita moltiplicando ciascun valore di input per un fattore di scala. Il fattore di scala viene determinato in base a min_range e max_range in modo che sia il più grande possibile, così che l'intervallo da min_range a max_range sia rappresentabile all'interno di valori di tipo T. 

  

  

    
  const int min_T = std::numeric_limits::min();
  const int max_T = std::numeric_limits::max();
  const float max_float = std::numeric_limits::max();
  const float scale_factor_from_min_side =
      (min_T * min_range > 0) ? min_T / min_range : max_float;
  const float scale_factor_from_max_side =
      (max_T * max_range > 0) ? max_T / max_range : max_float;
  const float scale_factor = std::min(scale_factor_from_min_side,
                                      scale_factor_from_max_side);
 Successivamente, utilizziamo il fattore di scala per regolare min_range e max_range come segue: 
      min_range = min_T / scale_factor;
      max_range = max_T / scale_factor;
 Ad esempio, se T = qint8 e inizialmente min_range = -10 e max_range = 9, confronteremmo -128/-10.0 = 12.8 con 127/9.0 = 14.11 e imposteremmo scaling_factor = 12.8. In questo caso, min_range rimarrebbe -10, ma max_range verrebbe regolato a 127 / 12.8 = 9.921875.
 Quindi quantizzeremo i valori di input nell'intervallo da (-10, 9,921875) a (-128, 127).
 Il tensore di input può ora essere quantizzato troncando i valori all'intervallo min_range a max_range , quindi moltiplicandoli per scale_factor come segue: 
result = round(min(max_range, max(min_range, input)) * scale_factor)
 I min_range e max_range modificati vengono restituiti come output 2 e 3 di questa operazione. Questi output devono essere utilizzati come intervallo per eventuali calcoli successivi.
 attributo narrow_range (bool)
 Se impostato su true, non utilizziamo il valore quantizzato minimo. Ad esempio, per int8, l'output quantizzato sarebbe limitato all'intervallo -127..127 anziché all'intervallo completo -128..127. Questa impostazione è prevista per garantire la compatibilità con alcuni backend di inferenza. (Si applica solo alla modalità SCALED)
 attributo asse (int)
 Un attributo opzionale axis può specificare un indice di dimensione del tensore di input, in modo che gli intervalli di quantizzazione vengano calcolati e applicati separatamente per ogni sezione del tensore lungo quella dimensione. Ciò è utile per la quantizzazione per canale.
 Se l'asse è specificato, min_range e max_range
 se axis =None, la quantizzazione per tensore viene eseguita normalmente.
 attributo ensure_minimum_range (float)
 Garantisce che l'intervallo minimo di quantizzazione sia almeno pari a questo valore. Il valore predefinito precedente era 0,01, ma si consiglia vivamente di impostarlo a 0 per i nuovi utilizzi.
 Argomentazioni:
  •  ambito: un oggetto Scope
  •  min_range: Il valore minimo dell'intervallo di quantizzazione. Questo valore può essere regolato dall'operatore in base ad altri parametri. Il valore regolato viene scritto in output_min . Se viene specificato l'attributo axis , questo deve essere un tensore 1D la cui dimensione corrisponde alla dimensione axis dei tensori di input e output.
  •  max_range: Il valore massimo dell'intervallo di quantizzazione. Questo valore può essere regolato dall'operatore in base ad altri parametri. Il valore regolato viene scritto in output_max . Se viene specificato l'attributo axis , questo deve essere un tensore 1D la cui dimensione corrisponde alla dimensione axis dei tensori di input e output.
 Resi:
  •  Output output: I dati quantizzati prodotti dall'input float.
  •  Output output_min: Il valore minimo dell'intervallo di quantizzazione finale, utilizzato per troncare i valori di input prima di scalarli e arrotondarli ai valori quantizzati. Se l'attributo axis è specificato, si tratterà di un tensore 1D la cui dimensione corrisponde alla dimensione axis dei tensori di input e output.
  •  Output output_max: Il valore massimo dell'intervallo di quantizzazione finale, utilizzato per troncare i valori di input prima di scalarli e arrotondarli ai valori quantizzati. Se l'attributo axis è specificato, si tratterà di un tensore 1D la cui dimensione corrisponde alla dimensione axis dei tensori di input e 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
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool 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 
 Asse 
Attrs Axis(
  int64 x
)
 Garantire un intervallo minimo 
Attrs EnsureMinimumRange(
  float x
)
 Modalità 
Attrs Mode(
  StringPiece x
)
 Gamma ristretta 
Attrs NarrowRange(
  bool x
)
 Modalità rotonda 
Attrs RoundMode(
  StringPiece x
)