Tensorflow :: ops :: QuantizeV2

#include <array_ops.h>

Quantisieren Sie den 'Input'-Tensor vom Typ float zum' Output'-Tensor vom Typ 'T'.

Zusammenfassung

[min_range, max_range] sind skalare Floats, die den Bereich für die 'Eingabedaten' angeben. Das Attribut 'mode' steuert genau, welche Berechnungen verwendet werden, um die Gleitkommawerte in ihre quantisierten Äquivalente umzuwandeln. Das Attribut 'round_mode' steuert, welcher Algorithmus zum Aufbrechen der Rundungsbindung verwendet wird, wenn Float-Werte auf ihre quantisierten Äquivalente gerundet werden.

Im Modus 'MIN_COMBINED' wird jeder Wert des Tensors wie folgt durchlaufen:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

hier range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

Beispiel für den MIN_COMBINED-Modus

Angenommen, die Eingabe ist vom Typ float und hat einen möglichen Bereich von [0.0, 6.0] und der Ausgabetyp ist quint8 ([0, 255]). Die Werte für min_range und max_range sollten als 0.0 und 6.0 angegeben werden. Durch Quantisieren von float zu quint8 wird jeder Wert der Eingabe mit 255/6 multipliziert und in quint8 umgewandelt.

Wenn der Ausgabetyp qint8 war ([-128, 127]), subtrahiert die Operation vor dem Umwandeln zusätzlich jeden Wert um 128, sodass der Wertebereich mit dem Bereich von qint8 übereinstimmt.

Wenn der Modus 'MIN_FIRST' ist, wird dieser Ansatz verwendet:

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

Der größte Unterschied zwischen diesem und MIN_COMBINED besteht darin, dass der Mindestbereich zuerst gerundet wird, bevor er vom gerundeten Wert abgezogen wird. Mit MIN_COMBINED wird eine kleine Verzerrung eingeführt, bei der wiederholte Iterationen des Quantisierens und Dequantisierens einen immer größeren Fehler verursachen.

SCALED-Modus Beispiel

SCALED Modus entspricht dem in QuantizeAndDequantize{V2|V3} verwendeten QuantizeAndDequantize{V2|V3} .

Wenn der Modus SCALED , wird die Quantisierung durchgeführt, indem jeder Eingabewert mit einem Skalierungsfaktor multipliziert wird. Der Skalierungsfaktor wird aus min_range und max_range so groß wie möglich bestimmt, sodass der Bereich von min_range bis max_range innerhalb von Werten vom Typ T dargestellt werden kann.

  

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

Als nächstes verwenden wir den scale_factor, um min_range und max_range wie folgt anzupassen:

      min_range = min_T / scale_factor;
      max_range = max_T / scale_factor;

Beispiel: Wenn T = qint8 und anfänglich min_range = -10 und max_range = 9, würden wir -128 / -10,0 = 12,8 mit 127 / 9,0 = 14,11 vergleichen und scaling_factor = 12,8 setzen. In diesem Fall würde min_range -10 bleiben. aber max_range würde auf 127 / 12.8 = 9.921875 angepasst

Wir werden also Eingabewerte im Bereich (-10, 9.921875) bis (-128, 127) quantisieren.

Der Eingangstensor kann jetzt quantisiert werden, indem Werte auf den Bereich min_range bis max_range und dann wie folgt mit max_range multipliziert werden:

result = round(min(max_range, max(min_range, input)) * scale_factor)

Der angepasste min_range und max_range werden als Ausgänge 2 und 3 dieser Operation zurückgegeben. Diese Ausgänge sollten als Bereich für weitere Berechnungen verwendet werden.

Narrow_Range (Bool) -Attribut

Wenn dies zutrifft, verwenden wir nicht den minimalen quantisierten Wert. dh für int8 die quantisierte Ausgabe wäre sie auf den Bereich -127..127 anstelle des vollen Bereichs -128..127 beschränkt. Dies ist aus Gründen der Kompatibilität mit bestimmten Inferenz-Backends vorgesehen. (Gilt nur für den SCALED-Modus)

Achse (int) Attribut

Ein optionales axis kann einen Dimensionsindex des Eingangstensors angeben, sodass Quantisierungsbereiche für jede Schicht des Tensors entlang dieser Dimension separat berechnet und angewendet werden. Dies ist nützlich für die Quantisierung pro Kanal.

Wenn Achse angegeben ist, min_range und max_range

Wenn axis = Keine, wird die Quantisierung pro Tensor wie gewohnt durchgeführt.

Attribut sure_minimum_range (float)

Stellt sicher, dass der minimale Quantisierungsbereich mindestens diesen Wert beträgt. Der alte Standardwert hierfür ist 0,01, es wird jedoch dringend empfohlen, ihn für neue Verwendungszwecke auf 0 zu setzen.

Argumente:

  • scope: Ein Scope- Objekt
  • min_range: Der Mindestwert des Quantisierungsbereichs. Dieser Wert kann abhängig von anderen Parametern durch die Operation eingestellt werden. Der angepasste Wert wird in output_min . Wenn das axis angegeben ist, muss dies ein 1-D-Tensor sein, dessen Größe mit der axis der Eingangs- und Ausgangstensoren übereinstimmt.
  • max_range: Der Maximalwert des Quantisierungsbereichs. Dieser Wert kann abhängig von anderen Parametern durch die Operation eingestellt werden. Der angepasste Wert wird in output_max . Wenn das axis angegeben ist, muss dies ein 1-D-Tensor sein, dessen Größe mit der axis der Eingangs- und Ausgangstensoren übereinstimmt.

Kehrt zurück:

  • Output Ausgabe: Die quantisierten Daten, die aus der Float-Eingabe erzeugt werden.
  • Output output_min: Das endgültige Minimum des Quantisierungsbereichs, mit dem Eingabewerte abgeschnitten werden, bevor sie skaliert und auf quantisierte Werte gerundet werden. Wenn das axis angegeben ist, ist dies ein 1-D-Tensor, dessen Größe mit der axis der Eingangs- und Ausgangstensoren übereinstimmt.
  • Output output_max: Das endgültige Maximum des Quantisierungsbereichs, mit dem Eingabewerte abgeschnitten werden, bevor sie skaliert und auf quantisierte Werte gerundet werden. Wenn das axis angegeben ist, handelt es sich um einen 1-D-Tensor, dessen Größe mit der axis der Eingangs- und Ausgangstensoren übereinstimmt.

Konstruktoren und Destruktoren

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)

Öffentliche Attribute

operation
output
output_max
output_min

Öffentliche statische Funktionen

Axis (int64 x)
EnsureMinimumRange (float x)
Mode (StringPiece x)
NarrowRange (bool x)
RoundMode (StringPiece x)

Strukturen

tensorflow :: ops :: QuantizeV2 :: Attrs

Optionale Attributsetzer für QuantizeV2 .

Öffentliche Attribute

Operation

Operation operation

Ausgabe

::tensorflow::Output output

output_max

::tensorflow::Output output_max

output_min

::tensorflow::Output output_min

Öffentliche Funktionen

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
)

Öffentliche statische Funktionen

Achse

Attrs Axis(
  int64 x
)

Stellen Sie sicher, dass der Mindestbereich erreicht ist

Attrs EnsureMinimumRange(
  float x
)

Modus

Attrs Mode(
  StringPiece x
)

Engen Bereich

Attrs NarrowRange(
  bool x
)

RoundMode

Attrs RoundMode(
  StringPiece x
)