Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Quantisierung nach dem Training

Die Quantisierung nach dem Training ist eine Konvertierungstechnik, mit der die Modellgröße reduziert und gleichzeitig die Latenzzeit für CPU und Hardwarebeschleuniger verbessert werden kann, wobei die Modellgenauigkeit nur geringfügig beeinträchtigt wird. Sie können ein bereits trainiertes Float-TensorFlow-Modell quantisieren, wenn Sie es mit dem TensorFlow Lite-Konverter in das TensorFlow Lite-Format konvertieren .

Optimierungsmethoden

Es stehen mehrere Quantisierungsoptionen nach dem Training zur Auswahl. Hier ist eine Übersichtstabelle der Auswahlmöglichkeiten und der Vorteile, die sie bieten:

Technik Leistungen Hardware
Quantisierung des Dynamikbereichs 4x kleiner, 2x-3x schneller Zentralprozessor
Vollständige ganzzahlige Quantisierung 4x kleiner, 3x + Beschleunigung CPU, Edge TPU, Mikrocontroller
Float16-Quantisierung 2x kleinere GPU-Beschleunigung CPU, GPU

Der folgende Entscheidungsbaum kann Ihnen dabei helfen, festzustellen, welche Quantisierungsmethode nach dem Training für Ihren Anwendungsfall am besten geeignet ist:

Optimierungsoptionen nach dem Training

Quantisierung des Dynamikbereichs

Die einfachste Form der Quantisierung nach dem Training quantisiert statisch nur die Gewichte vom Gleitkomma bis zur Ganzzahl mit einer Genauigkeit von 8 Bit:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

Inferenz werden Gewichte von 8-Bit-Genauigkeit in Gleitkomma konvertiert und unter Verwendung von Gleitkomma-Kerneln berechnet. Diese Konvertierung wird einmal durchgeführt und zwischengespeichert, um die Latenz zu verringern.

Um die Latenz weiter zu verbessern, quantisieren "Dynamic-Range" -Operatoren Aktivierungen dynamisch basierend auf ihrem Bereich auf 8 Bit und führen Berechnungen mit 8-Bit-Gewichten und -Aktivierungen durch. Diese Optimierung bietet Latenzen nahe der vollständigen Festpunktinferenz. Die Ausgänge werden jedoch weiterhin mit Gleitkommazahlen gespeichert, sodass die Beschleunigung bei Operationen mit dynamischem Bereich geringer ist als bei einer vollständigen Festkomma-Berechnung.

Vollständige ganzzahlige Quantisierung

Sie können weitere Latenzverbesserungen erzielen, die maximale Speichernutzung reduzieren und die Kompatibilität mit nur ganzzahligen Hardwaregeräten oder Beschleunigern gewährleisten, indem Sie sicherstellen, dass die gesamte Modellmathematik ganzzahlig quantisiert ist.

Für eine vollständige Ganzzahlquantisierung müssen Sie den Dynamikbereich von Aktivierungen und Eingaben messen, indem Sie dem Konverter Probeneingabedaten bereitstellen. Weitere Informationen finden Sie in der im folgenden Code verwendeten Funktion representative_dataset_gen() .

Ganzzahl mit Float-Fallback (unter Verwendung der Standard-Float-Eingabe / Ausgabe)

Führen Sie die folgenden Schritte aus, um ein Modell vollständig integer zu quantisieren, aber Float-Operatoren zu verwenden, wenn keine Integer-Implementierung vorhanden ist (um sicherzustellen, dass die Konvertierung reibungslos erfolgt):

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
tflite_quant_model = converter.convert()

Nur Ganzzahl

Das Erstellen von Nur-Ganzzahl-Modellen ist ein häufiger Anwendungsfall für TensorFlow Lite für Mikrocontroller und Coral Edge-TPUs .

Um die Kompatibilität mit Nur-Integer-Geräten (z. B. 8-Bit-Mikrocontrollern) und Beschleunigern (z. B. der Coral Edge-TPU) sicherzustellen, können Sie außerdem die vollständige Integer-Quantisierung für alle Operationen einschließlich Eingabe und Ausgabe mithilfe der folgenden Schritte erzwingen:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8  # or tf.uint8
tflite_quant_model = converter.convert()

Float16-Quantisierung

Sie können die Größe eines Gleitkommamodells reduzieren, indem Sie die Gewichte auf float16, den IEEE-Standard für 16-Bit-Gleitkommazahlen, quantisieren. Führen Sie die folgenden Schritte aus, um die float16-Quantisierung von Gewichten zu aktivieren:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_quant_model = converter.convert()

Die Vorteile der float16-Quantisierung sind folgende:

  • Es reduziert die Modellgröße um bis zur Hälfte (da alle Gewichte die Hälfte ihrer ursprünglichen Größe erreichen).
  • Dies führt zu einem minimalen Genauigkeitsverlust.
  • Es unterstützt einige Delegaten (z. B. den GPU-Delegaten), die direkt mit float16-Daten arbeiten können, was zu einer schnelleren Ausführung führt als float32-Berechnungen.

Die Nachteile der float16-Quantisierung sind wie folgt:

  • Es reduziert die Latenz nicht so sehr wie eine Quantisierung auf Festkomma-Mathematik.
  • Standardmäßig "dequantisiert" ein quantisiertes float16-Modell die Gewichtungswerte auf float32, wenn es auf der CPU ausgeführt wird. (Beachten Sie, dass der GPU-Delegat diese Dequantisierung nicht durchführt, da er mit float16-Daten arbeiten kann.)

Nur Ganzzahl: 16-Bit-Aktivierungen mit 8-Bit-Gewichten (experimentell)

Dies ist ein experimentelles Quantisierungsschema. Es ähnelt dem Schema "nur Ganzzahl", aber Aktivierungen werden basierend auf ihrem Bereich bis 16 Bit quantisiert, Gewichte werden in 8-Bit-Ganzzahlen quantisiert und die Vorspannung wird in 64-Bit-Ganzzahlen quantisiert. Dies wird weiter als 16 × 8-Quantisierung bezeichnet.

Der Hauptvorteil dieser Quantisierung besteht darin, dass sie die Genauigkeit erheblich verbessern kann, die Modellgröße jedoch nur geringfügig erhöht.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]
tflite_quant_model = converter.convert()

Wenn die 16x8-Quantisierung für einige Operatoren im Modell nicht unterstützt wird, kann das Modell weiterhin quantisiert werden, aber nicht unterstützte Operatoren bleiben im Float. Die folgende Option sollte der Zielspezifikation hinzugefügt werden, um dies zu ermöglichen.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
def representative_dataset_gen():
  for _ in range(num_calibration_steps):
    # Get sample input data as a numpy array in a method of your choosing.
    yield [input]
converter.representative_dataset = representative_dataset_gen
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8,
tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_quant_model = converter.convert()

Beispiele für Anwendungsfälle, bei denen durch dieses Quantisierungsschema Genauigkeitsverbesserungen erzielt werden, sind: * Superauflösung, * Audiosignalverarbeitung wie Rauschunterdrückung und Strahlformung, * Bildentrauschen, * HDR-Rekonstruktion aus einem einzelnen Bild.

Der Nachteil dieser Quantisierung ist:

  • Derzeit ist die Inferenz aufgrund des Fehlens einer optimierten Kernel-Implementierung merklich langsamer als eine 8-Bit-Ganzzahl.
  • Derzeit ist es nicht mit den vorhandenen hardwarebeschleunigten TFLite-Delegaten kompatibel.

Ein Tutorial für diesen Quantisierungsmodus finden Sie hier .

Modellgenauigkeit

Da Gewichte nach dem Training quantisiert werden, kann es insbesondere bei kleineren Netzwerken zu Genauigkeitsverlusten kommen. Im TensorFlow Lite-Modellrepository werden vorab trainierte, vollständig quantisierte Modelle für bestimmte Netzwerke bereitgestellt. Es ist wichtig, die Genauigkeit des quantisierten Modells zu überprüfen, um sicherzustellen, dass eine Verschlechterung der Genauigkeit innerhalb akzeptabler Grenzen liegt. Es gibt Tools zur Bewertung der Genauigkeit des TensorFlow Lite-Modells .

Wenn der Genauigkeitsabfall zu hoch ist, sollten Sie alternativ ein quantisierungsbewusstes Training in Betracht ziehen. Dies erfordert jedoch Änderungen während des Modelltrainings, um gefälschte Quantisierungsknoten hinzuzufügen, während die Quantisierungstechniken nach dem Training auf dieser Seite ein vorhandenes vorab trainiertes Modell verwenden.

Darstellung für quantisierte Tensoren

Die 8-Bit-Quantisierung approximiert Gleitkommawerte unter Verwendung der folgenden Formel.

$$real\_value = (int8\_value - zero\_point) \times scale$$

Die Darstellung besteht aus zwei Hauptteilen:

  • Gewichte pro Achse (auch bekannt als pro Kanal) oder pro Tensor, dargestellt durch die Komplementwerte von int8 two im Bereich [-127, 127] mit einem Nullpunkt von 0.

  • Aktivierungen / Eingaben pro Tensor, dargestellt durch die Komplementwerte von int8 two im Bereich [-128, 127], mit einem Nullpunkt im Bereich [-128, 127].

Eine detaillierte Ansicht unseres Quantisierungsschemas finden Sie in unserer Quantisierungsspezifikation . Hardwareanbieter, die sich an die Delegatenschnittstelle von TensorFlow Lite anschließen möchten, werden aufgefordert, das dort beschriebene Quantisierungsschema zu implementieren.