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

SageMaker Neo a besoin de modèles d'apprentissage automatique pour satisfaire des formes de données d'entrée spécifiques. La forme d'entrée requise pour la compilation dépend du cadre de deep learning que vous utilisez. Une fois votre modèle formaté à la forme d'entrée correcte, enregistrez-le conformément aux exigences ci-dessous. Lorsque vous disposez d'un modèle enregistré, compressez les artefacts du modèle.

Quelles sont les formes de données d'entrée attendues par SageMaker Neo ?

Avant de compiler votre modèle, assurez-vous qu'il est correctement formaté. Pour Neo, le nom et la forme des entrées de données pour votre modèle entraîné doivent être au format JSON ou au format liste. Les entrées attendues sont spécifiques au cadre.

Vous trouverez ci-dessous les formes d'entrée attendues par SageMaker Neo :

Keras

Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le modèle entraîné. Notez que si les artefacts du modèle Keras doivent être téléchargés au format NHWC (channel-last), ils DataInputConfig doivent être spécifiés au format NCHW (channel-first). Voici quels sont les formats de dictionnaire requis :

• Pour une entrée : {'input_1':[1,3,224,224]}

• Pour deux entrées : {'input_1': [1,3,224,224], 'input_2':[1,3,224,224]}

MXnet/ONNX

Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le modèle entraîné. Voici quels sont les formats de dictionnaire requis :

• Pour une entrée : {'data':[1,3,1024,1024]}

• Pour deux entrées : {'var1': [1,1,28,28], 'var2':[1,1,28,28]}

PyTorch

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 :

• Vous avez créé votre fichier de définition de modèle à l'aide de la PyTorch version 2.0 ou d'une version ultérieure. Pour plus d'informations sur la création du fichier de définition, consultez la PyTorch section intitulée Enregistrer des modèles pour SageMaker Neo.

• Vous compilez votre modèle pour une instance cloud. Pour plus d'informations sur les types d'instances pris en charge par SageMaker Neo, consultezCadres et types d'instance pris en charge.

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 (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le 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 :

• Pour une entrée au format dictionnaire : {'input0':[1,3,224,224]}

• Pour une entrée au format liste : [[1,3,224,224]]

• Pour deux entrées au format dictionnaire : {'input0':[1,3,224,224], 'input1':[1,3,224,224]}

• Pour deux entrées au format liste : [[1,3,224,224], [1,3,224,224]]

TensorFlow

Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :

• Pour une entrée : {'input':[1,1024,1024,3]}

• Pour deux entrées : {'data1': [1,28,28,1], 'data2':[1,28,28,1]}

TFLite

Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :

• Pour une entrée : {'input':[1,224,224,3]}

Note

SageMaker Neo prend uniquement en charge la version TensorFlow Lite pour les cibles périphériques. Pour obtenir la liste des appareils cibles SageMaker Neo Edge compatibles, consultez la Appareils page SageMaker Neo. Pour obtenir la liste des cibles d'instances cloud SageMaker Neo prises en charge, consultez la Cadres et types d'instance pris en charge page SageMaker Neo.

XGBoost

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

Modèles d'épargne pour SageMaker Neo

Les exemples de code suivants montrent comment enregistrer votre modèle pour le rendre compatible avec Neo. Les modèles doivent être packagés sous forme de fichiers tar compressés (*.tar.gz).

Keras

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 :

1. Exporter au format .h5 avec model.save("<model-name>", save_format="h5").

2. Figer le SavedModel après l'exportation.

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

Avertissement

N'exportez pas votre modèle avec la classe SavedModel en utilisant model.save(<path>, save_format='tf'). Ce format convient à l'entraînement, mais pas à l'inférence.

MXNet

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

Gluon Models

Définissez le réseau neuronal à l'aide de la classe HybridSequential. Le code s'exécutera dans le style d'une programmation symbolique (par opposition à une programmation impérative).

from mxnet import nd, sym
from mxnet.gluon import nn

def get_net():
    net = nn.HybridSequential()  # Here we use the class HybridSequential.
    net.add(nn.Dense(256, activation='relu'),
            nn.Dense(128, activation='relu'),
            nn.Dense(2))
    net.initialize()
    return net

# Define an input to compute a forward calculation. 
x = nd.random.normal(shape=(1, 512))
net = get_net()

# During the forward calculation, the neural network will automatically infer
# the shape of the weight parameters of all the layers based on the shape of
# the input.
net(x)
                        
# hybridize model
net.hybridize()
net(x)

# export model
net.export('<model_name>') # this will create model-symbol.json and model-0000.params files

import tarfile
tar = tarfile.open("<model_name>.tar.gz", "w:gz")
for name in ["<model_name>-0000.params", "<model_name>-symbol.json"]:
    tar.add(name)
tar.close()

Pour de plus amples informations sur l'hybridation de modèles, veuillez consulter la Documentation d'hybridation MXNet.

Gluon Model Zoo (GluonCV)

Les modèles de zoo GluonCV sont pré-hybridés. Vous pouvez donc simplement les exporter.

import numpy as np
import mxnet as mx
import gluoncv as gcv
from gluoncv.utils import export_block
import tarfile

net = gcv.model_zoo.get_model('<model_name>', pretrained=True) # For example, choose <model_name> as resnet18_v1
export_block('<model_name>', net, preprocess=True, layout='HWC')

tar = tarfile.open("<model_name>.tar.gz", "w:gz")

for name in ["<model_name>-0000.params", "<model_name>-symbol.json"]:
    tar.add(name)
tar.close()

Non Gluon Models

Lorsque les modèles sans gluon sont enregistrés sur disque, ils utilisent tous des fichiers *-symbol et *.paramsfichiers. Ils sont donc déjà au bon format pour Neo.

# Pass the following 3 parameters: sym, args, aux
mx.model.save_checkpoint('<model_name>',0,sym,args,aux) # this will create <model_name>-symbol.json and <model_name>-0000.params files

import tarfile
tar = tarfile.open("<model_name>.tar.gz", "w:gz")

for name in ["<model_name>-0000.params", "<model_name>-symbol.json"]:
    tar.add(name)
tar.close()

PyTorch

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 la torch.jit.trace méthode, consultez TORCH.JIT.TRACE dans la documentation. PyTorch

TensorFlow

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 :

• c : création d'une archive

• z : compression de l'archive avec gzip

• v : affichage de la progression de l'archive

• f : spécification du nom de fichier de l'archive

Estimateurs intégrés

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 compile_model du SDK Python : SageMaker

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 le SDK SageMaker Python, consultez. Compiler un modèle (Amazon SageMaker SDK)