Préparation d'un modèle pour la compilation

Spécifiez le nom et la forme (NCHWformat) des entrées de données attendues à l'aide d'un format de dictionnaire pour votre modèle entraîné. Notez que si les artefacts du modèle Keras doivent être téléchargés au format NHWC (dernier canal), ils DataInputConfig doivent être spécifiés au format NCHW (canal d'abord). Voici quels sont les formats de dictionnaire requis :

Spécifiez le nom et la forme (NCHWformat) des entrées de données attendues à l'aide d'un format de dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :

Pour un PyTorch modèle, il n'est pas nécessaire de fournir le nom et la forme des entrées de données attendues si vous remplissez les deux conditions suivantes :

Si vous remplissez ces conditions, SageMaker Neo obtient la configuration d'entrée à partir du fichier de définition du modèle (.pt ou .pth) que vous créez avec. PyTorch

Sinon, vous devez exécuter les actions suivantes :

Spécifiez le nom et la forme (NCHWformat) des entrées de données attendues à l'aide d'un format de dictionnaire pour votre modèle entraîné. Vous pouvez aussi spécifier la forme en utilisant uniquement un format liste. Voici quels sont les formats de dictionnaire requis :

Spécifiez le nom et la forme (NHWCformat) des entrées de données attendues à l'aide d'un format de dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :

Spécifiez le nom et la forme (NHWCformat) des entrées de données attendues à l'aide d'un format de dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :

Le nom et la forme des données d'entrée ne sont pas nécessaires.

Les modèles Keras ont besoin d'un fichier de définition de modèle (.h5).

Il existe deux options pour enregistrer votre modèle Keras afin de le rendre compatible avec SageMaker Neo :

Voici un exemple d'exportation d'un modèle tf.keras sous forme de graphique figé (option deux) :

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

MXNetles modèles doivent être enregistrés sous la forme d'un fichier de symboles unique *-symbol.json et d'un seul paramètre*.params files.

PyTorch les modèles doivent être enregistrés sous forme de fichier de définition (.ptou.pth) avec le type de données d'entrée de. float32

Pour enregistrer votre modèle, utilisez la torch.jit.trace méthode suivie par la torch.save méthode. Ce processus enregistre un objet sur un fichier disque et utilise par défaut python pickle (pickle_module=pickle) pour enregistrer les objets et certaines métadonnées. Ensuite, convertissez le modèle enregistré en un fichier tar compressé.

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

Si vous enregistrez votre modèle avec la PyTorch version 2.0 ou une version ultérieure, SageMaker Neo déduit la configuration d'entrée du modèle (le nom et la forme de son entrée) à partir du fichier de définition. Dans ce cas, il n'est pas nécessaire de spécifier la configuration d'entrée de données SageMaker lors de la compilation du modèle.

Si vous souhaitez empêcher SageMaker Neo de dériver la configuration d'entrée, vous pouvez définir le _store_inputs paramètre torch.jit.trace toFalse. Dans ce cas, vous devez spécifier la configuration d'entrée de données SageMaker lors de la compilation du modèle.

Pour plus d'informations sur torch.jit.trace cette méthode, consultez TORCH. JIT. TRACEdans la PyTorch documentation.

TensorFlow nécessite un .pb ou un .pbtxt fichier et un répertoire de variables contenant des variables. Pour les modèles figés, un seul fichier .pb ou .pbtxt est nécessaire.

L'exemple de code suivant montre comment compresser votre modèle à l'aide de la commande tar Linux. Exécutez les opérations suivantes sur votre terminal ou dans un bloc-notes Jupyter (si vous utilisez un bloc-notes Jupyter, insérez la commande magique !au début de l'énoncé) :

# 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

Les indicateurs de commande utilisés dans cet exemple accomplissent les tâches suivantes :

Les estimateurs intégrés sont réalisés par des conteneurs spécifiques au cadre ou des conteneurs spécifiques à l'algorithme. Les objets d'estimateurs intégrés spécifiques à l'algorithme et au cadre enregistrent le modèle au format correct pour vous lorsque vous entraînez le modèle à l'aide de la méthode intégrée .fit.

Par exemple, vous pouvez utiliser a sagemaker.TensorFlow pour définir un TensorFlow estimateur :

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

Ensuite, entraînez le modèle avec la méthode intégrée .fit :

estimator.fit(inputs)

Avant de terminer la compilation du modèle avec la méthode intégrée compile_model :

# 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')

Vous pouvez également utiliser la sagemaker.estimator.Estimator classe pour initialiser un objet estimateur afin d'entraîner et de compiler un algorithme intégré avec la méthode Python compile_model : SageMaker SDK

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

Pour plus d'informations sur la compilation de modèles avec SageMaker PythonSDK, consultezCompiler un modèle (Amazon SageMakerSDK).