tensorflow :: ops :: QuantizeV2

#include <array_ops.h>

Quantizza il tensore "input" di tipo float sul tensore "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 spareggio di arrotondamento viene utilizzato quando si arrotondano i valori float ai loro equivalenti quantizzati.

Nella 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 ogni valore per 128 prima del cast, in modo che l'intervallo di valori sia allineato 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 , la quantizzazione viene eseguita moltiplicando ogni valore di input per un fattore di scala. Il fattore di scala è determinato da min_range e max_range per essere il più ampio possibile in modo tale che l'intervallo da min_range a max_range sia rappresentabile entro 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 utilizzeremo 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 intervallo_min = -10 e intervallo_max = 9, dovremmo confrontare -128 / -10.0 = 12,8 con 127 / 9,0 = 14,11 e impostare fattore_scaling = 12,8 In questo caso, intervallo_min rimarrebbe -10, ma intervallo_max 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 tagliando 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 vengono restituiti come uscite 2 e 3 di questa operazione. Questi output dovrebbero essere usati come intervallo per ulteriori calcoli.

attributo narrow_range (bool)

Se vero, non usiamo il valore quantizzato minimo. cioè per int8 l'uscita quantizzata, sarebbe limitata all'intervallo -127..127 invece dell'intervallo completo -128..127. Viene fornito per compatibilità con alcuni backend di inferenza. (Si applica solo alla modalità SCALED)

attributo axis (int)

Un attributo axis opzionale 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 sezione del tensore lungo quella dimensione. Questo è utile per la quantizzazione per canale.

Se viene specificato l'asse, intervallo_min e intervallo_max

se axis = Nessuno, la quantizzazione per tensore viene eseguita normalmente.

attributo garantire_minimum_range (float)

Assicura 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 i nuovi usi.

Argomenti:

  • scope: un oggetto Scope
  • intervallo_min: il valore minimo dell'intervallo di quantizzazione. Questo valore può essere regolato dall'op in base ad altri parametri. Il valore regolato viene scritto in output_min . Se viene specificato l'attributo axis , questo deve essere un tensore 1-D la cui dimensione corrisponda alla dimensione axis dei tensori di ingresso e di uscita.
  • max_range: il valore massimo dell'intervallo di quantizzazione. Questo valore può essere regolato dall'op in base ad altri parametri. Il valore regolato viene scritto in output_max . Se viene specificato l'attributo axis , deve essere un tensore 1-D la cui dimensione corrisponde alla dimensione axis dei tensori di ingresso e di uscita.

Ritorna:

  • Output output: i dati quantizzati prodotti dall'ingresso 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 viene specificato l'attributo axis , questo sarà un tensore 1-D la cui dimensione corrisponde alla dimensione axis dei tensori di ingresso e di uscita.
  • Output output_max: l'intervallo di quantizzazione finale massimo, utilizzato per ritagliare i valori di input prima di ridimensionarli e arrotondarli a valori quantizzati. Se viene specificato l'attributo axis , sarà un tensore 1-D la cui dimensione corrisponde alla dimensione axis dei tensori di ingresso e di 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

Axis (int64 x)
EnsureMinimumRange (float x)
Mode (StringPiece x)
NarrowRange (bool 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

Asse

Attrs Axis(
  int64 x
)

GuaranteMinimumRange

Attrs EnsureMinimumRange(
  float x
)

Modalità

Attrs Mode(
  StringPiece x
)

Gamma ristretta

Attrs NarrowRange(
  bool x
)

RoundMode

Attrs RoundMode(
  StringPiece x
)