Prepare o modelo para compilação

Especifique o nome e a forma (NCHWformato) das entradas de dados esperadas usando um formato de dicionário para seu modelo treinado. Observe que, embora os artefatos do modelo Keras devam ser carregados no formato NHWC (último canal), DataInputConfig devem ser especificados no formato NCHW (primeiro canal). Os formatos de dicionário necessários são os seguintes:

Especifique o nome e a forma (NCHWformato) das entradas de dados esperadas usando um formato de dicionário para seu modelo treinado. Os formatos de dicionário necessários são os seguintes:

Para um PyTorch modelo, você não precisa fornecer o nome e a forma das entradas de dados esperadas se atender às duas condições a seguir:

Se você atender a essas condições, SageMaker o Neo obtém a configuração de entrada do arquivo de definição do modelo (.pt ou .pth) com o qual você cria. PyTorch

Caso contrário, você deverá fazer o seguinte:

Especifique o nome e a forma (NCHWformato) das entradas de dados esperadas usando um formato de dicionário para seu modelo treinado. Como alternativa, você pode especificar a forma usando um formato de lista. Os formatos de dicionário necessários são os seguintes:

Especifique o nome e a forma (NHWCformato) das entradas de dados esperadas usando um formato de dicionário para seu modelo treinado. Os formatos de dicionário necessários são os seguintes:

Especifique o nome e a forma (NHWCformato) das entradas de dados esperadas usando um formato de dicionário para seu modelo treinado. Os formatos de dicionário necessários são os seguintes:

O nome e a forma de dados de entrada não são necessários.

Os modelos Keras exigem um arquivo de definição de modelo (.h5).

Há duas opções para salvar seu modelo Keras para torná-lo compatível com SageMaker o Neo:

Veja abaixo um exemplo de como exportar um tf.keras modelo como um gráfico congelado (opção dois):

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

MXNetos modelos devem ser salvos como um único arquivo de símbolo *-symbol.json e um único parâmetro*.params files.

PyTorch os modelos devem ser salvos como um arquivo de definição (.ptou.pth) com o tipo de dados de entrada de. float32

Para salvar seu modelo, use o método torch.jit.trace seguido pelo método torch.save. Esse processo salva um objeto em um arquivo de disco e, por padrão, usa python pickle (pickle_module=pickle) para salvar os objetos e alguns metadados. Em seguida, converta o modelo salvo em um arquivo tar compactado.

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

Se você salvar seu modelo com PyTorch 2.0 ou posterior, SageMaker o Neo deriva a configuração de entrada do modelo (o nome e a forma de sua entrada) do arquivo de definição. Nesse caso, você não precisa especificar a configuração de entrada de dados SageMaker ao compilar o modelo.

Se você quiser evitar que SageMaker o Neo obtenha a configuração de entrada, você pode definir o _store_inputs parâmetro de torch.jit.trace to. False Se você fizer isso, deverá especificar a configuração de entrada de dados para SageMaker quando compilar o modelo.

Para obter mais informações sobre o torch.jit.trace método, consulte TORCH. JIT. TRACEna PyTorch documentação.

TensorFlow requer um .pb ou um .pbtxt arquivo e um diretório de variáveis que contenha variáveis. Para modelos congelados, apenas um arquivo .pb ou .pbtxt é necessário.

O exemplo de código a seguir mostra como usar o comando Linux tar para compactar o modelo. Execute o seguinte em seu terminal ou em um caderno Jupyter (se você usa um caderno Jupyter, insira o comando mágico ! no início da instrução):

# 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

Os sinalizadores de comando usados neste exemplo realizam o seguinte:

Os estimadores integrados são feitos por contêineres específicos da estrutura ou contêineres específicos do algoritmo. Os objetos estimadores do algoritmo incorporado e do estimador específico da estrutura salvam o modelo no formato correto quando você treina o modelo usando o método incorporado .fit.

Por exemplo, você pode usar sagemaker.TensorFlow a para definir um TensorFlow estimador:

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

Em seguida, treine o modelo com o método .fit integrado:

estimator.fit(inputs)

Antes de finalmente compilar o modelo com o método compile_model integrado:

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

Você também pode usar a sagemaker.estimator.Estimator Classe para inicializar um objeto estimador para treinar e compilar um algoritmo integrado com o método compile_model do Python: 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')

Para obter mais informações sobre a compilação de modelos com o SageMaker SDK Python, consulte. Compilar um modelo (Amazon SageMakerSDK)