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

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

SageMaker Neo a besoin que les modèles de machine learning répondent à une forme de données d'entrée spécifique. 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.

De quelles formes de données d'entrée SageMaker Neo a-t-il besoin ?

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.

Voici les formes d'entrée que SageMaker Neo attend :

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é. Bien que les artefacts du modèle Keras doivent être téléchargés au format NHWC (canal dernier), DataInputConfig doit être spécifié au format NCHW (canal premier). 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]}

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]}

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]]

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]}

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 TensorFlow Lite pour les appareils cibles en périphérie. Pour obtenir la liste des appareils cibles SageMaker Neo en périphérie pris en charge, veuillez consulter la page SageMaker Neo Devices. Pour obtenir la liste des instances cloud cibles SageMaker Neo prises en charge, veuillez consulter la page SageMaker Neo Cadres et types d'instance pris en charge.

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

Enregistrement de modèles 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).

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

Deux options vous permettent d'enregistrer votre modèle Keras pour 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.

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

Les modèles PyTorch doivent être enregistrés en tant que fichier de définition (.pt ou .pth) avec le type de données d'entrée float32.

Pour enregistrer votre modèle, utilisez torch.jit.trace suivi de torch.save. Cela enregistre un objet dans 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()

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

Pre-Trained Model

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

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 un sagemaker.TensorFlow pour définir un estimateur TensorFlow :

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 classe sagemaker.estimator.Estimator pour initialiser un objet estimateur pour l'entraînement et la compilation d'un algorithme intégré avec la méthode compile_model du SDK SageMaker Python :

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 de plus amples informations sur la compilation de modèles avec le SDK SageMaker Python, veuillez consulter Compilation d'un modèle (SDK Amazon SageMaker).