[PYTHON] TensorFlow 2.X & TensorRT ist der erste Schritt, um die Inferenz zu beschleunigen

Einführung

Unter Verwendung des Modells von Keras-Anwendungen schreibe ich kurz die Konvertierung und den Rückschluss auf das Modell für TensorRT. Installationen wie TensorRT sind nicht verfügbar, da sie den NVIDIA GPU Cloud-Container verwenden.

Vorbereitung

Voraussetzungen

• Docker installiert --Und ein GPU-Container ist verfügbar

Starten Sie die Ausführungsumgebung

Starten Sie die Ausführungsumgebung wie folgt. Da Jupyter bereits installiert ist, können Sie den folgenden Code auf Jupyter ausprobieren.

docker run -it --rm --gpus all -p 8888:8888 --shm-size=1g --ulimit memlock=-1 --ulimit stack=67108864 nvcr.io/nvidia/tensorflow:20.02-tf2-py3 bash

# (Optional)
jupyter lab

--nvcr.io / nvidia / tensorflow ist ein Container, der in der NVIDIA GPU Cloud registriert ist. --TensorFlow 2.1, TensorRT 7.0 und andere Jupyter sind bereits in diesem Container installiert.

• (Optional) shm-size, ulimit: Da der Hauptspeicher beim Konvertieren des Modells häufig verwendet wird, wird er auch als Gegenmaßnahme für Speicherzuordnungsfehler festgelegt.
• (Optional) 8888-Port ist für Jupyter.

Referenz: Wachstumseinstellung

Speicherbeschränkungen für Fehlergegenmaßnahmen, die häufig bei Verwendung von Keras auftreten.

Beispiel für eine Speicherbegrenzung

import tensorflow as tf

for dev in tf.config.experimental.list_physical_devices('GPU'):
    tf.config.experimental.set_memory_growth(dev, True)

Umwandlung

Zunächst wird das Zielmodell ausgegeben. Der Punkt ist ** Format speichern **. Geben Sie "tf" für "save_format" an und speichern Sie es mit Tensorflow Saved Model. (Nicht erforderlich, da dies die Standardeinstellung in TensorFlow 2.X ist.)

Modellspeicher in Keras

from tensorflow.keras.applications.vgg16 import VGG16

model = VGG16(weights='imagenet')
model.save('./vgg16', save_format='tf')

Dann transformieren Sie das Modell.

Float32-Version (Single Precision Floating Point) mit TensorRT-Konvertierung

from tensorflow.python.compiler.tensorrt import trt_convert as trt

converter = trt.TrtGraphConverterV2(input_saved_model_dir='./vgg16',
                                    conversion_params=trt.DEFAULT_TRT_CONVERSION_PARAMS)
converter.convert()
converter.save('./vgg16-tensorrt')

Halbpräzise Gleitkommaversion

Wenn Sie mit Float16 konvertieren möchten, ändern Sie die Parameter des Konverters.

converter = trt.TrtGraphConverterV2(input_saved_model_dir='./vgg16',
                                    conversion_params=trt.DEFAULT_TRT_CONVERSION_PARAMS._replace(precision_mode=trt.TrtPrecisionMode.FP16))

Ganzzahlige Version

Wenn Sie eine 8-Bit-Ganzzahl erstellen möchten, müssen Sie sie kalibrieren. Ich denke, Sie sollten die zum Lernen verwendeten Daten verwenden.

In dieser VGG16-Einstellung wird es als Form von $ (N, 224, 224, 3) $ übergeben.

import numpy as np

def calibration_input_fn():  #Datengenerierungsfunktion zur Kalibrierung
    yield np.random.uniform(size=(5, 224, 224, 3)).astype(np.float32),  #Am Ende,Vergiss nicht

converter = trt.TrtGraphConverterV2(input_saved_model_dir='./vgg16',
                                    conversion_params=trt.DEFAULT_TRT_CONVERSION_PARAMS._replace(precision_mode=trt.TrtPrecisionMode.INT8, use_calibration=True))
converter.convert(calibration_input_fn=calibration_input_fn)
converter.save('./vgg16-tensorrt')

Inferenz

Laden Sie das transformierte Modell und rufen Sie die für die Inferenz verwendeten Objekte ab. Dann wird die Inferenz ausgeführt, indem dieses Objekt als Funktion aufgerufen wird.

model = tf.saved_model.load('./vgg16-tensorrt', tags=[tf.saved_model.SERVING])
infer = model.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]

#Dummy-Eingabe
x = np.random.uniform(size=(3, 224, 224, 3)).astype(np.float32)
#Inferenz
y = infer(tf.convert_to_tensor(x))['predictions']

Referenz: Die Eingabeform kann unten verwendet werden.

infer.inputs[0].shape
>>> TensorShape([None, 224, 224, 3])

Vergleich der Ausführungsergebnisse

Abschließend ein grober Vergleich der Ausführungsergebnisse (TensorRT oben). Auch wenn es so geeignet ist, wird die Ausführungsgeschwindigkeit verbessert. Da die Speichernutzung ebenfalls abnimmt, können wir anscheinend verschiedene Dinge tun, z. B. mehrere Modelle ausführen, und ich denke, dass sich der Grad des Nutzens in Abhängigkeit von der GPU-Architektur der Ausführungsumgebung stark ändern wird.

Ausführungsumgebung: GeForce GTX 1080 Ti