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 implantação
Nesta seção, você criará objetos de SageMaker IA e de AWS IoT cliente, fará o download de um modelo de aprendizado de máquina pré-treinado, carregará seu modelo no bucket do Amazon S3, compilará seu modelo para seu dispositivo de destino SageMaker com o Neo e empacotará seu modelo para que ele possa ser implantado com o agente do Edge Manager.
1. **Importe bibliotecas e crie objetos de cliente.**
Este tutorial usa o AWS SDK para Python (Boto3) para criar clientes para interagir com SageMaker IA, Amazon S3 e. AWS IoT
Importe o Boto3, especifique sua região e inicialize os objetos do cliente necessários, conforme mostrado no seguinte exemplo:
```
import boto3
import json
import time
AWS_REGION = 'us-west-2'# Specify your Region
bucket = {{'bucket-name'}}
sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)
iot_client = boto3.client('iot', region_name=AWS_REGION)
```
Defina variáveis e atribua a elas o ARN da função que você criou para a SageMaker IA e AWS IoT como strings:
```
# Replace with the role ARN you created for SageMaker
sagemaker_role_arn = "arn:aws:iam::{{:role/*}}"
# Replace with the role ARN you created for AWS IoT.
# Note: The name must start with 'SageMaker'
iot_role_arn = "arn:aws:iam::{{:role/SageMaker*}}"
```
1. **Treinar um modelo de machine learning.**
Consulte [Treinar um modelo com a Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) para obter mais informações sobre como treinar um modelo de aprendizado de máquina usando SageMaker IA. Se preferir, carregue seu modelo treinado localmente diretamente em um bucket de URI do Amazon S3.
Se você ainda não tiver um modelo, pode usar um modelo pré-treinado para as próximas etapas deste tutorial. Por exemplo, você pode salvar os modelos MobileNet V2 da TensorFlow estrutura. MobileNet O V2 é um modelo de classificação de imagens otimizado para aplicativos móveis. Para obter mais informações sobre a MobileNet V2, consulte o [MobileNet GitHub README](https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet).
Digite o seguinte em seu notebook Jupyter para salvar o modelo V2 pré-treinado MobileNet :
```
# Save the MobileNet V2 model to local storage
import tensorflow as tf
model = tf.keras.applications.MobileNetV2()
model.save(“mobilenet_v2.h5”)
```
**nota**
Se você não tiver TensorFlow instalado, poderá fazer isso executando `pip install tensorflow=2.4`
Use a TensorFlow versão 2.4 ou inferior para este tutorial.
O modelo será salvo no arquivo `mobilenet_v2.h5`. Antes de empacotar o modelo, você precisará primeiro compilar seu modelo usando SageMaker o Neo. Verifique [Estruturas, dispositivos, sistemas e arquiteturas compatíveis](neo-supported-devices-edge.md) se sua versão do TensorFlow (ou outra estrutura de sua escolha) é atualmente suportada pelo SageMaker Neo.
SageMaker O Neo exige que os modelos sejam armazenados como um arquivo TAR compactado. Reempacote-o como um arquivo TAR compactado (\*.tar.gz):
```
# Package MobileNet V2 model into a TAR file
import tarfile
tarfile_name='mobilenet-v2.tar.gz'
with tarfile.open(tarfile_name, mode='w:gz') as archive:
archive.add('mobilenet-v2.h5')
```
1. **Faça upload de seus arquivos para o Amazon S3.**
Depois de treinar seu modo de machine learning, armazene-o em um bucket S3 do Amazon. *O exemplo a seguir usa um AWS CLI comando para carregar o modelo para o bucket do Amazon S3 que você criou anteriormente em um diretório chamado models.* Digite o seguinte em seu caderno Jupyter:
```
!aws s3 cp mobilenet-v2.tar.gz s3://{bucket}/models/
```
1. **Compile seu modelo com o SageMaker Neo.**
Compile seu modelo de aprendizado de máquina com SageMaker o Neo para um dispositivo de ponta. Você precisa conhecer o URI do bucket do Amazon S3 onde você armazenou o modelo treinado, a estrutura de machine learning que você usou para treinar seu modelo, a forma da entrada do seu modelo e seu dispositivo de destino.
Para o modelo MobileNet V2, use o seguinte:
```
framework = 'tensorflow'
target_device = 'jetson_nano'
data_shape = '{"data":[1,3,224,224]}'
```
SageMaker O Neo requer uma forma de entrada de modelo e um formato de modelo específicos com base na estrutura de aprendizado profundo que você usa. Para obter mais informações sobre como salvar seu modelo, consulte [Quais formatos de dados de entrada o SageMaker Neo espera?](neo-compilation-preparing-model.md#neo-job-compilation-expected-inputs). Para obter mais informações sobre os dispositivos e frameworks compatíveis com o Neo, consulte [Estruturas, dispositivos, sistemas e arquiteturas compatíveis](neo-supported-devices-edge.md).
Use a `CreateCompilationJob` API para criar um trabalho de compilação com SageMaker o Neo. Forneça um nome para o trabalho de compilação, o ARN da função de SageMaker IA, o URI do Amazon S3 em que seu modelo está armazenado, a forma de entrada do modelo, o nome da estrutura, o URI do Amazon S3 em que você SageMaker deseja que a IA armazene seu modelo compilado e o destino do seu dispositivo de ponta.
```
# Specify the path where your model is stored
model_directory = 'models'
s3_model_uri = 's3://{}/{}/{}'.format(bucket, model_directory, tarfile_name)
# Store compiled model in S3 within the 'compiled-models' directory
compilation_output_dir = 'compiled-models'
s3_output_location = 's3://{}/{}/'.format(bucket, compilation_output_dir)
# Give your compilation job a name
compilation_job_name = 'getting-started-demo'
sagemaker_client.create_compilation_job(CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
InputConfig={
'S3Uri': s3_model_uri,
'DataInputConfig': data_shape,
'Framework' : framework.upper()},
OutputConfig={
'S3OutputLocation': s3_output_location,
'TargetDevice': target_device},
StoppingCondition={'MaxRuntimeInSeconds': 900})
```
1. **Empacote seu modelo compilado.**
Os trabalhos de empacotamento SageMaker usam modelos compilados pelo NEO e fazem as alterações necessárias para implantar o modelo com o mecanismo de inferência, o agente do Edge Manager. Para empacotar seu modelo, crie um trabalho de empacotamento de borda com a `create_edge_packaging` API ou o console de SageMaker IA.
Você precisa fornecer o nome usado para o trabalho de compilação do Neo, um nome para o trabalho de empacotamento, um ARN da função (consulte a seção [Configuração](edge-getting-started-step1.md)), um nome para o modelo, uma versão do modelo e o URI do bucket do Amazon S3 para a saída do trabalho de empacotamento. Observe que os nomes de tarefas de empacotamento do Edge Manager diferenciam maiúsculas e minúsculas. Veja a seguir um exemplo de como criar um trabalho de empacotamento usando a API.
```
edge_packaging_name='edge-packaging-demo'
model_name="sample-model"
model_version="1.1"
```
Defina o URI do Amazon S3 em que deseja armazenar o modelo empacotado.
```
# Output directory where you want to store the output of the packaging job
packaging_output_dir = 'packaged_models'
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)
```
Use `CreateEdgePackagingJob` para empacotar seu Neo-compiled modelo. Forneça um nome para seu trabalho de empacotamento de borda e o nome que você forneceu para seu trabalho de compilação (neste exemplo, ele foi armazenado na variável `compilation_job_name`). Forneça também um nome para seu modelo, uma versão para seu modelo (isso é usado para ajudá-lo a controlar qual versão do modelo você está usando) e o URI do S3 em que você deseja que a SageMaker IA armazene o modelo empacotado.
```
sagemaker_client.create_edge_packaging_job(
EdgePackagingJobName=edge_packaging_name,
CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
ModelName=model_name,
ModelVersion=model_version,
OutputConfig={
"S3OutputLocation": packaging_s3_output
}
)
```