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 , la quantizzazione viene eseguita moltiplicando ciascun valore di input per uno scaling_factor. Lo scaling_factor è determinato da min_range e max_range in modo che sia il più ampio possibile in modo tale 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 scale_factor 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, confronteremo -128/-10.0 = 12.8 con 127/9.0 = 14.11 e imposteremo scaling_factor = 12.8 In questo caso, min_range rimarrebbe -10, ma max_range verrebbe regolato su 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 ritagliando i valori nell'intervallo da min_range a max_range , quindi moltiplicando 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. Queste uscite dovrebbero essere utilizzate come intervallo per eventuali ulteriori calcoli.
 Attributo narrow_range (bool).
 Se vero, non utilizziamo il valore quantizzato minimo. cioè per int8 l'output quantizzato, sarebbe limitato all'intervallo -127..127 anziché all'intero intervallo -128..127. Questo è fornito per 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 tale che gli intervalli di quantizzazione verranno calcolati e applicati separatamente per ciascuna fetta del tensore lungo quella dimensione. Ciò è utile per la quantizzazione per canale.
 Se è specificato l'asse, intervallo_min e intervallo_max
 se axis = Nessuno, la quantizzazione per tensore viene eseguita normalmente.
 Attributo Guarantee_minimum_range (float).
 Garantisce che l'intervallo di quantizzazione minimo sia almeno questo valore. Il valore predefinito legacy per questo è 0,01, ma si consiglia vivamente di impostarlo su 0 per nuovi usi.
 Argomenti:
  •  scope: 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 modificato viene scritto in output_min . Se l'attributo axis è specificato, questo deve essere un tensore 1-D 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 modificato viene scritto in output_max . Se l'attributo axis è specificato, questo deve essere un tensore 1-D 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 minimo dell'intervallo di quantizzazione finale, utilizzato per ritagliare i valori di input prima di ridimensionarli e arrotondarli a valori quantizzati. Se l'attributo axis è specificato, questo sarà un tensore 1-D la cui dimensione corrisponde alla dimensione axis dei tensori di input e output.
  •  Output output_max: il massimo dell'intervallo di quantizzazione finale, utilizzato per ritagliare i valori di input prima di ridimensionarli e arrotondarli a valori quantizzati. Se l'attributo axis è specificato, questo sarà un tensore 1-D 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 pubbliche statiche
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool 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 
 Asse 
Attrs Axis(
  int64 x
)
 GuaranteeIntervallo minimo 
Attrs EnsureMinimumRange(
  float x
)
 Modalità 
Attrs Mode(
  StringPiece x
)
 Raggio ristretto 
Attrs NarrowRange(
  bool x
)
 Modalità rotonda 
Attrs RoundMode(
  StringPiece x
)