Modell für die Kompilierung vorbereiten

Sie müssen den Namen und die Form (NCHW-Format) erwarteter Dateneingaben unter Verwendung eines Wörterbuchformats für Ihr trainiertes Modell angeben. Beachten Sie, dass Keras-Modellartefakte zwar im NHWC-Format (channel-last) hochgeladen werden sollten, jedoch im NCHW-Format (channel-first) angegeben werden sollte. Gültige Wörterbuchformate sind folgende:

Sie müssen den Namen und die Form (NCHW-Format) erwarteter Dateneingaben unter Verwendung eines Wörterbuchformats für Ihr trainiertes Modell angeben. Gültige Wörterbuchformate sind folgende:

Für ein PyTorch-Modell müssen Sie den Namen und die Form der erwarteten Dateneingaben nicht angeben, wenn Sie die beiden folgenden Bedingungen erfüllen:

Wenn Sie diese Bedingungen erfüllen, ruft SageMaker Neo die Eingabekonfiguration aus der Modelldefinitionsdatei (.pt oder .pth) ab, die Sie mit PyTorch erstellen.

Andernfalls müssen Sie wie folgt vorgehen:

Sie müssen den Namen und die Form (NCHW-Format) erwarteter Dateneingaben unter Verwendung eines Wörterbuchformats für Ihr trainiertes Modell angeben. Alternativ können Sie die Form nur in einem Listenformat angeben. Gültige Wörterbuchformate sind folgende:

Sie müssen den Namen und die Form (NHWC-Format) der erwarteten Dateneingaben unter Verwendung eines Wörterbuchformats für Ihr trainiertes Modell angeben. Gültige Wörterbuchformate sind folgende:

Sie müssen den Namen und die Form (NHWC-Format) der erwarteten Dateneingaben unter Verwendung eines Wörterbuchformats für Ihr trainiertes Modell angeben. Gültige Wörterbuchformate sind folgende:

Der Name und die Form der Eingabedaten sind nicht erforderlich.

Keras-Modelle benötigen eine Modelldefinitionsdatei (.h5).

Es gibt zwei Möglichkeiten, Ihr Keras-Modell zu speichern, um es für SageMaker Neo kompatibel zu machen:

Im Folgenden finden Sie ein Beispiel für den Export eines tf.keras Modells als eingefrorenes Diagramm (Option zwei):

import os
import tensorflow as tf
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras import backend

tf.keras.backend.set_learning_phase(0)
model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3), pooling='avg')
model.summary()

# Save as a SavedModel
export_dir = 'saved_model/'
model.save(export_dir, save_format='tf')

# Freeze saved model
input_node_names = [inp.name.split(":")[0] for inp in model.inputs]
output_node_names = [output.name.split(":")[0] for output in model.outputs]
print("Input names: ", input_node_names)
with tf.Session() as sess:
    loaded = tf.saved_model.load(sess, export_dir=export_dir, tags=["serve"]) 
    frozen_graph = tf.graph_util.convert_variables_to_constants(sess,
                                                                sess.graph.as_graph_def(),
                                                                output_node_names)
    tf.io.write_graph(graph_or_graph_def=frozen_graph, logdir=".", name="frozen_graph.pb", as_text=False)

import tarfile
tar = tarfile.open("frozen_graph.tar.gz", "w:gz")
tar.add("frozen_graph.pb")
tar.close()

MXNet-Modelle müssen als einzelne Symboldatei *-symbol.json und als einziger Parameter *.params files gespeichert werden.

PyTorch-Modelle müssen als Definitionsdatei (.ptoder.pth) mit dem Eingabedatentyp von float32 gespeichert werden.

Verwenden Sie die Methode, gefolgt von der torch.save Methode, um Ihr torch.jit.trace Modell zu speichern. Dieser Prozess speichert ein Objekt in einer Festplattendatei und verwendet standardmäßig Python pickle (pickle_module=pickle), um die Objekte und einige Metadaten zu speichern. Als Nächstes konvertieren Sie das gespeicherte Modell in eine komprimierte TAR-Datei.

import torchvision
import torch

model = torchvision.models.resnet18(pretrained=True)
model.eval()
inp = torch.rand(1, 3, 224, 224)
model_trace = torch.jit.trace(model, inp)

# Save your model. The following code saves it with the .pth file extension
model_trace.save('model.pth')

# Save as a compressed tar file
import tarfile
with tarfile.open('model.tar.gz', 'w:gz') as f:
    f.add('model.pth')
f.close()

Wenn Sie Ihr Modell mit PyTorch 2.0 oder höher speichern, leitet SageMaker Neo die Eingabekonfiguration für das Modell (den Namen und die Form für die Eingabe) aus der Definitionsdatei ab. In diesem Fall müssen Sie die Dateneingabekonfiguration für SageMaker AI nicht festlegen, wenn Sie das Modell kompilieren.

Wenn Sie verhindern möchten, dass SageMaker Neo die Eingabekonfiguration ableitet, können Sie den _store_inputs Parameter von torch.jit.trace auf False setzen. In diesem Fall müssen Sie bei der Kompilierung des Modells die Dateneingabekonfiguration für SageMaker AI angeben.

Weitere Informationen zur torch.jit.trace Methode finden Sie unter TORCH.JIT.TRACE in der PyTorch-Dokumentation.

TensorFlow benötigt eine .pb oder eine .pbtxt Datei und ein Variablenverzeichnis, das Variablen enthält. Für eingefrorene Modelle ist nur eine .pb oder .pbtxt Datei erforderlich.

Das folgende Codebeispiel veranschaulicht, wie Sie den Befehl tar Linux verwenden, um Ihr Modell zu komprimieren. Führen Sie Folgendes in Ihrem Terminal oder in einem Jupyter Notebook aus (wenn Sie ein Jupyter Notebook verwenden, fügen Sie den ! magischen Befehl am Anfang der Anweisung ein):

# Download SSD_Mobilenet trained model
!wget http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v2_coco_2018_03_29.tar.gz

# unzip the compressed tar file
!tar xvf ssd_mobilenet_v2_coco_2018_03_29.tar.gz

# Compress the tar file and save it in a directory called 'model.tar.gz'
!tar czvf model.tar.gz ssd_mobilenet_v2_coco_2018_03_29/frozen_inference_graph.pb

Die in diesem Beispiel verwendeten Befehlsflags bewirken Folgendes:

Integrierte Schätzer werden entweder durch Framework-spezifische Container oder durch algorithmusspezifische Container erstellt. Schätzobjekte sowohl für den integrierten Algorithmus als auch für den Framework-spezifischen Schätzer speichern das Modell im richtigen Format für Sie, wenn Sie das Modell mit der integrierten .fit Methode trainieren.

Sie können beispielsweise a sagemaker.TensorFlow verwenden, um einen TensorFlow-Schätzer zu definieren:

from sagemaker.tensorflow import TensorFlow

estimator = TensorFlow(entry_point='mnist.py',
                        role=role,  #param role can be arn of a sagemaker execution role
                        framework_version='1.15.3',
                        py_version='py3',
                        training_steps=1000, 
                        evaluation_steps=100,
                        instance_count=2,
                        instance_type='ml.c4.xlarge')

Trainieren Sie dann das Modell mit .fit integrierten Methode:

estimator.fit(inputs)

Bevor Sie das Modell schließlich mit der Build-In compile_model Methode kompilieren:

# Specify output path of the compiled model
output_path = '/'.join(estimator.output_path.split('/')[:-1])

# Compile model
optimized_estimator = estimator.compile_model(target_instance_family='ml_c5', 
                              input_shape={'data':[1, 784]},  # Batch size 1, 3 channels, 224x224 Images.
                              output_path=output_path,
                              framework='tensorflow', framework_version='1.15.3')

Sie können die sagemaker.estimator.Estimator Klasse auch verwenden, um ein Schätzerobjekt für das Training und die Kompilierung eines integrierten Algorithmus mit der compile_model Methode aus dem SageMaker Python SDK zu initialisieren:

import sagemaker
from sagemaker.image_uris import retrieve
sagemaker_session = sagemaker.Session()
aws_region = sagemaker_session.boto_region_name

# Specify built-in algorithm training image
training_image = retrieve(framework='image-classification', 
                          region=aws_region, image_scope='training')

training_image = retrieve(framework='image-classification', region=aws_region, image_scope='training')

# Create estimator object for training
estimator = sagemaker.estimator.Estimator(image_uri=training_image,
                                          role=role,  #param role can be arn of a sagemaker execution role
                                          instance_count=1,
                                          instance_type='ml.p3.8xlarge',
                                          volume_size = 50,
                                          max_run = 360000,
                                          input_mode= 'File',
                                          output_path=s3_training_output_location,
                                          base_job_name='image-classification-training'
                                          )
                                          
# Setup the input data_channels to be used later for training.                                          
train_data = sagemaker.inputs.TrainingInput(s3_training_data_location,
                                            content_type='application/x-recordio',
                                            s3_data_type='S3Prefix')
validation_data = sagemaker.inputs.TrainingInput(s3_validation_data_location,
                                                content_type='application/x-recordio',
                                                s3_data_type='S3Prefix')
data_channels = {'train': train_data, 'validation': validation_data}


# Train model
estimator.fit(inputs=data_channels, logs=True)

# Compile model with Neo                                                                                  
optimized_estimator = estimator.compile_model(target_instance_family='ml_c5',
                                          input_shape={'data':[1, 3, 224, 224], 'softmax_label':[1]},
                                          output_path=s3_compilation_output_location,
                                          framework='mxnet',
                                          framework_version='1.7')

Weitere Informationen zum Kompilieren von Modellen mit dem SageMaker Python SDK finden Sie unter Kompilieren eines Modells (Amazon SageMaker AI SDK):