As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Prepare o modelo para compilação
SageMaker O Neo exige modelos de aprendizado de máquina para satisfazer formas específicas de dados de entrada. O formato de entrada necessário para a compilação depende da estrutura de aprendizado profundo que você usa. Depois que a forma de entrada do modelo estiver formatada corretamente, salve seu modelo de acordo com os requisitos abaixo. Depois de salvar um modelo, comprima os artefatos do modelo.
**Topics**
+ [Quais formatos de dados de entrada o SageMaker Neo espera?](#neo-job-compilation-expected-inputs)
+ [Salvando modelos para SageMaker Neo](#neo-job-compilation-how-to-save-model)
## Quais formatos de dados de entrada o SageMaker Neo espera?
Antes de compilar seu modelo, verifique se ele está formatado corretamente. O Neo espera o nome e a forma das entradas de dados esperadas para o seu modelo treinado com um formato JSON ou de lista. As entradas esperadas são específicas da estrutura.
Abaixo estão as formas de entrada que SageMaker Neo espera:
### Keras
Especifique o nome e a forma (formato NCHW) das entradas dos dados esperados 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:
+ Para uma entrada: `{'input_1':[1,3,224,224]}`
+ Para duas entradas: `{'input_1': [1,3,224,224], 'input_2':[1,3,224,224]}`
### MXNet/ONNX
Especifique o nome e a forma (formato NCHW) das entradas dos dados esperados usando um formato de dicionário para seu modelo treinado. Os formatos de dicionário necessários são os seguintes:
+ Para uma entrada: `{'data':[1,3,1024,1024]}`
+ Para duas entradas: `{'var1': [1,1,28,28], 'var2':[1,1,28,28]}`
### PyTorch
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:
+ Você criou seu arquivo de definição de modelo usando PyTorch 2.0 ou posterior. Para obter mais informações sobre como criar o arquivo de definição, consulte a [PyTorch](#how-to-save-pytorch) seção *Salvando modelos para SageMaker o Neo*.
+ Você está compilando seu modelo para uma instância de nuvem. Para obter mais informações sobre os tipos de instância compatíveis com SageMaker o Neo, consulte[Tipos e estruturas de instância compatíveis](neo-supported-cloud.md).
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 (formato NCHW) das entradas dos dados esperados 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:
+ Exemplos para uma entrada em formato de dicionário: `{'input0':[1,3,224,224]}`
+ Para uma entrada em formato de lista: `[[1,3,224,224]]`
+ Exemplos para duas entradas em formato de dicionário: `{'input0':[1,3,224,224], 'input1':[1,3,224,224]}`
+ Para duas entradas em formato de lista: `[[1,3,224,224], [1,3,224,224]]`
### TensorFlow
Especifique o nome e a forma (formato NHWC) das entradas de dados esperadas usando um formato de dicionário para o seu modelo treinado. Os formatos de dicionário necessários são os seguintes:
+ Para uma entrada: `{'input':[1,1024,1024,3]}`
+ Para duas entradas: `{'data1': [1,28,28,1], 'data2':[1,28,28,1]}`
### TFlite
Especifique o nome e a forma (formato NHWC) das entradas de dados esperadas usando um formato de dicionário para o seu modelo treinado. Os formatos de dicionário necessários são os seguintes:
+ Para uma entrada: `{'input':[1,224,224,3]}`
**nota**
SageMaker O Neo suporta apenas o TensorFlow Lite para alvos de dispositivos periféricos. Para obter uma lista de alvos de dispositivos SageMaker Neo Edge compatíveis, consulte a [Dispositivos](neo-supported-devices-edge-devices.md#neo-supported-edge-devices) página SageMaker Neo. Para ver uma lista de destinos de instância de nuvem SageMaker Neo compatíveis, consulte a [Tipos e estruturas de instância compatíveis](neo-supported-cloud.md) página SageMaker Neo.
### XGBoost
O nome e a forma de dados de entrada não são necessários.
## Salvando modelos para SageMaker Neo
Os exemplos de código a seguir mostram como salvar o modelo para torná-lo compatível com o Neo. Os modelos devem ser empacotados como arquivos tar compactados (`*.tar.gz`).
### Keras
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:
1. Exporte para o formato `.h5` com `model.save("", save_format="h5")`.
1. Congele o `SavedModel` após a exportação.
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()
```
**Atenção**
Não exporte seu modelo com a classe `SavedModel` usando `model.save(, save_format='tf')`. Esse formato é adequado para treinamento, mas não é adequado para inferência.
### MXNet
Os modelos MXNet devem ser salvos como um único arquivo de símbolo `*-symbol.json` e um único parâmetro `*.params files`.
------
#### [ Gluon Models ]
Defina a rede neural usando a Classe `HybridSequential`. Isso executará o código no estilo de programação simbólica (em oposição à programação imperativa).
```
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('') # this will create model-symbol.json and model-0000.params files
import tarfile
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
Para obter mais informações sobre modelos de hibridização, consulte a [documentação de hibridização do MXNet](https://mxnet.apache.org/versions/1.7.0/api/python/docs/tutorials/packages/gluon/blocks/hybridize.html).
------
#### [ Gluon Model Zoo (GluonCV) ]
Os modelos zoo do GluonCV vêm pré-hibridizados. Então, você pode simplesmente exportá-los.
```
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('', pretrained=True) # For example, choose as resnet18_v1
export_block('', net, preprocess=True, layout='HWC')
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
------
#### [ Non Gluon Models ]
Todos os modelos não-Gluon, quando salvos em disco, usam arquivos `*-symbol` e `*.params`. Portanto, eles já estão no formato correto para o Neo.
```
# Pass the following 3 parameters: sym, args, aux
mx.model.save_checkpoint('',0,sym,args,aux) # this will create -symbol.json and -0000.params files
import tarfile
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
------
### PyTorch
PyTorch os modelos devem ser salvos como um arquivo de definição (`.pt`ou`.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 para a SageMaker IA 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 a SageMaker IA ao compilar o modelo.
Para obter mais informações sobre o `torch.jit.trace` método, consulte [TORCH.JIT.TRACE](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace)a PyTorch documentação.
### TensorFlow
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:
+ `c`: Criar um arquivamento
+ `z`: Comprimir o arquivo com gzip
+ `v`: Exibir o progresso do arquivamento
+ `f`: Especificar o nome do arquivo
### Built-In Estimadores
Built-in os estimadores 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 do SDK `compile_model` do 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')
```
Para obter mais informações sobre a compilação de modelos com o SDK do SageMaker Python, consulte. [Compilar um modelo (Amazon SageMaker AI SDK)](neo-job-compilation-sagemaker-sdk.md)