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á.
# Implantar um modelo
Para implantar um modelo SageMaker compilado pelo Amazon Neo em um endpoint HTTPS, você deve configurar e criar o endpoint para o modelo usando os serviços de hospedagem Amazon SageMaker AI. Atualmente, os desenvolvedores podem usar SageMaker APIs a Amazon para implantar módulos em instâncias ml.c5, ml.c4, ml.m5, ml.m4, ml.p3, ml.p2 e ml.inf1.
Para instâncias [Inferentia](https://aws.amazon.com/machine-learning/inferentia/) e [Trainium](https://aws.amazon.com/machine-learning/trainium/), os modelos precisam ser compilados especificamente para aquelas instâncias. Não há garantias de que os modelos compilados para outros tipos de instância funcionem com instâncias Inferentia ou Trainium.
Quando você implanta um modelo compilado, é necessário usar a mesma instância para o destino usado para compilação. Isso cria um endpoint de SageMaker IA que você pode usar para realizar inferências. [Você pode implantar um modelo compilado pelo NEO usando qualquer um dos seguintes: [Amazon SageMaker AI SDK para Python, SDK for Python](https://sagemaker.readthedocs.io/en/stable/)[(Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) e o console AI. [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/reference/)SageMaker ](https://console.aws.amazon.com/sagemaker)
**nota**
Para implantar um modelo usando AWS CLI o console ou o Boto3, consulte [Neo Inference Container Images para selecionar o URI da imagem de inferência para seu contêiner](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) primário.
**Topics**
+ [Pré-requisitos](neo-deployment-hosting-services-prerequisites.md)
+ [Implemente um modelo compilado usando o SageMaker SDK](neo-deployment-hosting-services-sdk.md)
+ [Implante um modelo compilado usando o Boto3](neo-deployment-hosting-services-boto3.md)
+ [Implemente um modelo compilado usando o AWS CLI](neo-deployment-hosting-services-cli.md)
+ [Implante um modelo compilado usando o console](neo-deployment-hosting-services-console.md)
# Pré-requisitos
**nota**
Siga as instruções nesta seção se você compilou seu modelo usando AWS SDK para Python (Boto3) AWS CLI, ou o console de SageMaker IA.
Para criar um modelo SageMaker neocompilado, você precisa do seguinte:
1. Um URI do Amazon ECR de imagem do Docker. Você pode selecionar um que atenda às suas necessidades [nesta lista](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html).
1. Um arquivo de script de ponto de entrada:
1. **Para PyTorch e MXNet modelos:**
*Se você treinou seu modelo usando SageMaker IA*, o script de treinamento deve implementar as funções descritas abaixo. O script de treinamento serve como o script de ponto de entrada durante a inferência. No exemplo detalhado em [Treinamento, compilação e implantação do MNIST com MXNet módulo e SageMaker Neo, o](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_neo_compilation_jobs/mxnet_mnist/mxnet_mnist_neo.html) script de treinamento (`mnist.py`) implementa as funções necessárias.
*Se você não treinou seu modelo usando SageMaker IA*, precisará fornecer um arquivo script (`inference.py`) de ponto de entrada que possa ser usado no momento da inferência. [Com base na estrutura — MXNet ou PyTorch — a localização do script de inferência deve estar em conformidade com a Estrutura de Diretórios do Modelo do SDK do SageMaker Python MxNet ou a [Estrutura de Diretórios do Modelo para](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#model-directory-structure). PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#model-directory-structure)
Ao usar imagens do Neo Inference Optimized Container com **PyTorch**e **MXNet**nos tipos de instância de CPU e GPU, o script de inferência deve implementar as seguintes funções:
+ `model_fn`: carrega o modelo. (Optional)
+ `input_fn`: converte a carga útil da solicitação recebida em uma matriz numérica.
+ `predict_fn`: executa a previsão.
+ `output_fn`: converte a saída de previsão na carga útil de resposta.
+ Como alternativa, você pode definir `transform_fn` para combinar `input_fn`, `predict_fn` e `output_fn`.
Veja a seguir exemplos de `inference.py` script em um diretório chamado `code` (`code/inference.py`) for **PyTorch and MXNet (Gluon and Module)**. Os exemplos primeiro carregam o modelo e depois o servem em dados de imagem em uma GPU:
------
#### [ MXNet Module ]
```
import numpy as np
import json
import mxnet as mx
import neomx # noqa: F401
from collections import namedtuple
Batch = namedtuple('Batch', ['data'])
# Change the context to mx.cpu() if deploying to a CPU endpoint
ctx = mx.gpu()
def model_fn(model_dir):
# The compiled model artifacts are saved with the prefix 'compiled'
sym, arg_params, aux_params = mx.model.load_checkpoint('compiled', 0)
mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None)
exe = mod.bind(for_training=False,
data_shapes=[('data', (1,3,224,224))],
label_shapes=mod._label_shapes)
mod.set_params(arg_params, aux_params, allow_missing=True)
# Run warm-up inference on empty data during model load (required for GPU)
data = mx.nd.empty((1,3,224,224), ctx=ctx)
mod.forward(Batch([data]))
return mod
def transform_fn(mod, image, input_content_type, output_content_type):
# pre-processing
decoded = mx.image.imdecode(image)
resized = mx.image.resize_short(decoded, 224)
cropped, crop_info = mx.image.center_crop(resized, (224, 224))
normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255,
mean=mx.nd.array([0.485, 0.456, 0.406]),
std=mx.nd.array([0.229, 0.224, 0.225]))
transposed = normalized.transpose((2, 0, 1))
batchified = transposed.expand_dims(axis=0)
casted = batchified.astype(dtype='float32')
processed_input = casted.as_in_context(ctx)
# prediction/inference
mod.forward(Batch([processed_input]))
# post-processing
prob = mod.get_outputs()[0].asnumpy().tolist()
prob_json = json.dumps(prob)
return prob_json, output_content_type
```
------
#### [ MXNet Gluon ]
```
import numpy as np
import json
import mxnet as mx
import neomx # noqa: F401
# Change the context to mx.cpu() if deploying to a CPU endpoint
ctx = mx.gpu()
def model_fn(model_dir):
# The compiled model artifacts are saved with the prefix 'compiled'
block = mx.gluon.nn.SymbolBlock.imports('compiled-symbol.json',['data'],'compiled-0000.params', ctx=ctx)
# Hybridize the model & pass required options for Neo: static_alloc=True & static_shape=True
block.hybridize(static_alloc=True, static_shape=True)
# Run warm-up inference on empty data during model load (required for GPU)
data = mx.nd.empty((1,3,224,224), ctx=ctx)
warm_up = block(data)
return block
def input_fn(image, input_content_type):
# pre-processing
decoded = mx.image.imdecode(image)
resized = mx.image.resize_short(decoded, 224)
cropped, crop_info = mx.image.center_crop(resized, (224, 224))
normalized = mx.image.color_normalize(cropped.astype(np.float32) / 255,
mean=mx.nd.array([0.485, 0.456, 0.406]),
std=mx.nd.array([0.229, 0.224, 0.225]))
transposed = normalized.transpose((2, 0, 1))
batchified = transposed.expand_dims(axis=0)
casted = batchified.astype(dtype='float32')
processed_input = casted.as_in_context(ctx)
return processed_input
def predict_fn(processed_input_data, block):
# prediction/inference
prediction = block(processed_input_data)
return prediction
def output_fn(prediction, output_content_type):
# post-processing
prob = prediction.asnumpy().tolist()
prob_json = json.dumps(prob)
return prob_json, output_content_type
```
------
#### [ PyTorch 1.4 and Older ]
```
import os
import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from PIL import Image
import io
import json
import pickle
def model_fn(model_dir):
"""Load the model and return it.
Providing this function is optional.
There is a default model_fn available which will load the model
compiled using SageMaker Neo. You can override it here.
Keyword arguments:
model_dir -- the directory path where the model artifacts are present
"""
# The compiled model is saved as "compiled.pt"
model_path = os.path.join(model_dir, 'compiled.pt')
with torch.neo.config(model_dir=model_dir, neo_runtime=True):
model = torch.jit.load(model_path)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# We recommend that you run warm-up inference during model load
sample_input_path = os.path.join(model_dir, 'sample_input.pkl')
with open(sample_input_path, 'rb') as input_file:
model_input = pickle.load(input_file)
if torch.is_tensor(model_input):
model_input = model_input.to(device)
model(model_input)
elif isinstance(model_input, tuple):
model_input = (inp.to(device) for inp in model_input if torch.is_tensor(inp))
model(*model_input)
else:
print("Only supports a torch tensor or a tuple of torch tensors")
return model
def transform_fn(model, request_body, request_content_type,
response_content_type):
"""Run prediction and return the output.
The function
1. Pre-processes the input request
2. Runs prediction
3. Post-processes the prediction output.
"""
# preprocess
decoded = Image.open(io.BytesIO(request_body))
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(
mean=[
0.485, 0.456, 0.406], std=[
0.229, 0.224, 0.225]),
])
normalized = preprocess(decoded)
batchified = normalized.unsqueeze(0)
# predict
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
batchified = batchified.to(device)
output = model.forward(batchified)
return json.dumps(output.cpu().numpy().tolist()), response_content_type
```
------
#### [ PyTorch 1.5 and Newer ]
```
import os
import torch
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision.transforms as transforms
from PIL import Image
import io
import json
import pickle
def model_fn(model_dir):
"""Load the model and return it.
Providing this function is optional.
There is a default_model_fn available, which will load the model
compiled using SageMaker Neo. You can override the default here.
The model_fn only needs to be defined if your model needs extra
steps to load, and can otherwise be left undefined.
Keyword arguments:
model_dir -- the directory path where the model artifacts are present
"""
# The compiled model is saved as "model.pt"
model_path = os.path.join(model_dir, 'model.pt')
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.jit.load(model_path, map_location=device)
model = model.to(device)
return model
def transform_fn(model, request_body, request_content_type,
response_content_type):
"""Run prediction and return the output.
The function
1. Pre-processes the input request
2. Runs prediction
3. Post-processes the prediction output.
"""
# preprocess
decoded = Image.open(io.BytesIO(request_body))
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(
mean=[
0.485, 0.456, 0.406], std=[
0.229, 0.224, 0.225]),
])
normalized = preprocess(decoded)
batchified = normalized.unsqueeze(0)
# predict
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
batchified = batchified.to(device)
output = model.forward(batchified)
return json.dumps(output.cpu().numpy().tolist()), response_content_type
```
------
1. **Para instâncias inf1 ou imagens de contêiner onnx, xgboost e keras**
Para todas as outras imagens de contêiner otimizadas pelo Neo Inference ou tipos de instância de inferência, o script de ponto de entrada deve implementar as seguintes funções para o Neo Deep Learning Runtime:
+ `neo_preprocess`: converte a carga útil da solicitação recebida em uma matriz numérica.
+ `neo_postprocess`: converte a saída de previsão do Neo Deep Learning Runtime no corpo da resposta.
**nota**
As duas funções anteriores não usam nenhuma das funcionalidades de MXNet PyTorch, ou. TensorFlow
Para obter exemplos de como usar essas funções, consulte [Blocos de anotações de amostra de compilação de modelos Neo](https://docs.aws.amazon.com//sagemaker/latest/dg/neo.html#neo-sample-notebooks).
1. **Para TensorFlow modelos**
Se seu modelo exigir uma lógica personalizada de pré e pós-processamento antes que os dados sejam enviados ao modelo, você deverá especificar um arquivo de script `inference.py` de ponto de entrada que possa ser usado no momento da inferência. O script deve implementar um par de funções `input_handler` e`output_handler` ou uma única função de manipulador.
**nota**
Observe que, se a função do manipulador for implementada, `input_handler` e `output_handler` são ignoradas.
Veja a seguir um exemplo de código de script `inference.py` que você pode montar com o modelo de compilação para realizar o pré-processamento e o pós-processamento personalizados em um modelo de classificação de imagens. O cliente SageMaker AI envia o arquivo de imagem como um tipo de `application/x-image` conteúdo para a `input_handler` função, onde ele é convertido em JSON. O arquivo de imagem convertido é então enviado para o [Tensorflow Model Server (TFX)](https://www.tensorflow.org/tfx/serving/api_rest) usando a API REST.
```
import json
import numpy as np
import json
import io
from PIL import Image
def input_handler(data, context):
""" Pre-process request input before it is sent to TensorFlow Serving REST API
Args:
data (obj): the request data, in format of dict or string
context (Context): an object containing request and configuration details
Returns:
(dict): a JSON-serializable dict that contains request body and headers
"""
f = data.read()
f = io.BytesIO(f)
image = Image.open(f).convert('RGB')
batch_size = 1
image = np.asarray(image.resize((512, 512)))
image = np.concatenate([image[np.newaxis, :, :]] * batch_size)
body = json.dumps({"signature_name": "serving_default", "instances": image.tolist()})
return body
def output_handler(data, context):
"""Post-process TensorFlow Serving output before it is returned to the client.
Args:
data (obj): the TensorFlow serving response
context (Context): an object containing request and configuration details
Returns:
(bytes, string): data to return to client, response content type
"""
if data.status_code != 200:
raise ValueError(data.content.decode('utf-8'))
response_content_type = context.accept_header
prediction = data.content
return prediction, response_content_type
```
Se não houver pré-processamento ou pós-processamento personalizado, o cliente de SageMaker IA converte a imagem do arquivo em JSON de forma semelhante antes de enviá-la para o SageMaker endpoint de IA.
Para obter mais informações, consulte [Implantação em endpoints de TensorFlow serviço no SDK do Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#providing-python-scripts-for-pre-pos-processing).
1. O URI do bucket do Amazon S3 que contém os artefatos do modelo compilado.
# Implemente um modelo compilado usando o SageMaker SDK
Você deve atender à seção de [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) se o modelo tiver sido compilado usando AWS SDK para Python (Boto3) o console Amazon AI ou o console Amazon SageMaker AI. AWS CLI Siga um dos seguintes casos de uso para implantar um modelo compilado com SageMaker o Neo com base em como você compilou seu modelo.
**Topics**
+ [Se você compilou seu modelo usando o SageMaker SDK](#neo-deployment-hosting-services-sdk-deploy-sm-sdk)
+ [Se você compilou seu modelo usando MXNet ou PyTorch](#neo-deployment-hosting-services-sdk-deploy-sm-boto3)
+ [Se você compilou seu modelo usando o Boto3, o SageMaker console ou a CLI para TensorFlow](#neo-deployment-hosting-services-sdk-deploy-sm-boto3-tensorflow)
## Se você compilou seu modelo usando o SageMaker SDK
O identificador de objeto [sagemaker.Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model) para o modelo compilado fornece a função [deploy()](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model#sagemaker.model.Model.deploy), que permite criar um endpoint para atender a solicitações de inferência. A função permite definir o número e o tipo de instâncias usadas para o endpoint. Você deve escolher uma instância para a qual compilou seu modelo. Por exemplo, no trabalho compilado na seção [Compilar um modelo (Amazon SageMaker SDK)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation-sagemaker-sdk.html), isso é. `ml_c5`
```
predictor = compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.c5.4xlarge')
# Print the name of newly created endpoint
print(predictor.endpoint_name)
```
## Se você compilou seu modelo usando MXNet ou PyTorch
Crie o modelo de SageMaker IA e implante-o usando a API deploy () no modelo específico da estrutura. APIs Pois MXNet, é [MXNetmodelo](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html?highlight=MXNetModel#mxnet-model) e para PyTorch, é [ PyTorchModel](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html?highlight=PyTorchModel#sagemaker.pytorch.model.PyTorchModel). Ao criar e implantar um modelo de SageMaker IA, você deve definir a variável de `MMS_DEFAULT_RESPONSE_TIMEOUT` ambiente `500` e especificar o `entry_point` parâmetro como o script de inferência (`inference.py`) e o `source_dir` parâmetro como a localização do diretório (`code`) do script de inferência. Para preparar o script de inferência (`inference.py`), siga a etapa Pré-requisitos.
O exemplo a seguir mostra como usar essas funções para implantar um modelo compilado usando o SageMaker AI SDK para Python:
------
#### [ MXNet ]
```
from sagemaker.mxnet import MXNetModel
# Create SageMaker model and deploy an endpoint
sm_mxnet_compiled_model = MXNetModel(
model_data='insert S3 path of compiled MXNet model archive',
role='AmazonSageMaker-ExecutionRole',
entry_point='inference.py',
source_dir='code',
framework_version='1.8.0',
py_version='py3',
image_uri='insert appropriate ECR Image URI for MXNet',
env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'},
)
# Replace the example instance_type below to your preferred instance_type
predictor = sm_mxnet_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge')
# Print the name of newly created endpoint
print(predictor.endpoint_name)
```
------
#### [ PyTorch 1.4 and Older ]
```
from sagemaker.pytorch import PyTorchModel
# Create SageMaker model and deploy an endpoint
sm_pytorch_compiled_model = PyTorchModel(
model_data='insert S3 path of compiled PyTorch model archive',
role='AmazonSageMaker-ExecutionRole',
entry_point='inference.py',
source_dir='code',
framework_version='1.4.0',
py_version='py3',
image_uri='insert appropriate ECR Image URI for PyTorch',
env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'},
)
# Replace the example instance_type below to your preferred instance_type
predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge')
# Print the name of newly created endpoint
print(predictor.endpoint_name)
```
------
#### [ PyTorch 1.5 and Newer ]
```
from sagemaker.pytorch import PyTorchModel
# Create SageMaker model and deploy an endpoint
sm_pytorch_compiled_model = PyTorchModel(
model_data='insert S3 path of compiled PyTorch model archive',
role='AmazonSageMaker-ExecutionRole',
entry_point='inference.py',
source_dir='code',
framework_version='1.5',
py_version='py3',
image_uri='insert appropriate ECR Image URI for PyTorch',
)
# Replace the example instance_type below to your preferred instance_type
predictor = sm_pytorch_compiled_model.deploy(initial_instance_count = 1, instance_type = 'ml.p3.2xlarge')
# Print the name of newly created endpoint
print(predictor.endpoint_name)
```
------
**nota**
As políticas `AmazonSageMakerFullAccess` e `AmazonS3ReadOnlyAccess` devem ser anexadas à função IAM `AmazonSageMaker-ExecutionRole`.
## Se você compilou seu modelo usando o Boto3, o SageMaker console ou a CLI para TensorFlow
Construa um objeto `TensorFlowModel` e chame implantar:
```
role='AmazonSageMaker-ExecutionRole'
model_path='S3 path for model file'
framework_image='inference container arn'
tf_model = TensorFlowModel(model_data=model_path,
framework_version='1.15.3',
role=role,
image_uri=framework_image)
instance_type='ml.c5.xlarge'
predictor = tf_model.deploy(instance_type=instance_type,
initial_instance_count=1)
```
Consulte [Implantação diretamente dos artefatos do modelo](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#deploying-directly-from-model-artifacts) para obter mais informações.
Você pode selecionar uma imagem do Docker (URI do Amazon ECR) que atenda às suas necessidades [nessa lista](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html).
Para obter mais informações sobre como construir um `TensorFlowModel` objeto, consulte o [SageMaker SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-serving-model).
**nota**
Sua primeira solicitação de inferência pode ter alta latência se você implantar seu modelo em uma GPU. Isso ocorre porque um kernel de computação otimizado é feito na primeira solicitação de inferência. Recomendamos que você crie um arquivo de aquecimento das solicitações de inferência e o armazene junto com seu arquivo de modelo antes de enviá-lo para um TFX. Isso é conhecido como “aquecimento” do modelo.
O trecho de código a seguir demonstra como produzir o arquivo de aquecimento para o exemplo de classificação de imagens na seção de [pré-requisitos:](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites)
```
import tensorflow as tf
from tensorflow_serving.apis import classification_pb2
from tensorflow_serving.apis import inference_pb2
from tensorflow_serving.apis import model_pb2
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_log_pb2
from tensorflow_serving.apis import regression_pb2
import numpy as np
with tf.python_io.TFRecordWriter("tf_serving_warmup_requests") as writer:
img = np.random.uniform(0, 1, size=[224, 224, 3]).astype(np.float32)
img = np.expand_dims(img, axis=0)
test_data = np.repeat(img, 1, axis=0)
request = predict_pb2.PredictRequest()
request.model_spec.name = 'compiled_models'
request.model_spec.signature_name = 'serving_default'
request.inputs['Placeholder:0'].CopyFrom(tf.compat.v1.make_tensor_proto(test_data, shape=test_data.shape, dtype=tf.float32))
log = prediction_log_pb2.PredictionLog(
predict_log=prediction_log_pb2.PredictLog(request=request))
writer.write(log.SerializeToString())
```
Para obter mais informações sobre como “aquecer” seu modelo, consulte a [página do TensorFlow TFX](https://www.tensorflow.org/tfx/serving/saved_model_warmup).
# Implante um modelo compilado usando o Boto3
Você deve atender à seção de [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) se o modelo tiver sido compilado usando AWS SDK para Python (Boto3) o console Amazon AI ou o console Amazon SageMaker AI. AWS CLI Siga as etapas abaixo para criar e implantar um modelo SageMaker neocompilado usando o [SDK da Amazon Web Services para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html).
**Topics**
+ [Implantar o modelo](#neo-deployment-hosting-services-boto3-steps)
## Implantar o modelo
Depois de satisfazer os [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), use o`create_model`, e. `create_enpoint_config` `create_endpoint` APIs
O exemplo a seguir mostra como usá-los para APIs implantar um modelo compilado com o Neo:
```
import boto3
client = boto3.client('sagemaker')
# create sagemaker model
create_model_api_response = client.create_model(
ModelName='my-sagemaker-model',
PrimaryContainer={
'Image': ,
'ModelDataUrl': 's3://path/to/model/artifact/model.tar.gz',
'Environment': {}
},
ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)
print ("create_model API response", create_model_api_response)
# create sagemaker endpoint config
create_endpoint_config_api_response = client.create_endpoint_config(
EndpointConfigName='sagemaker-neomxnet-endpoint-configuration',
ProductionVariants=[
{
'VariantName': ,
'ModelName': 'my-sagemaker-model',
'InitialInstanceCount': 1,
'InstanceType':
},
]
)
print ("create_endpoint_config API response", create_endpoint_config_api_response)
# create sagemaker endpoint
create_endpoint_api_response = client.create_endpoint(
EndpointName='provide your endpoint name',
EndpointConfigName=,
)
print ("create_endpoint API response", create_endpoint_api_response)
```
**nota**
As políticas `AmazonSageMakerFullAccess` e `AmazonS3ReadOnlyAccess` devem ser anexadas à função IAM `AmazonSageMaker-ExecutionRole`.
Para obter a sintaxe completa de `create_model``create_endpoint_config`, `create_endpoint` APIs, e, consulte [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), e [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint), respectivamente.
Se você não treinou seu modelo usando SageMaker IA, especifique as seguintes variáveis de ambiente:
------
#### [ MXNet and PyTorch ]
```
"Environment": {
"SAGEMAKER_PROGRAM": "inference.py",
"SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code",
"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
"SAGEMAKER_REGION": "insert your region",
"MMS_DEFAULT_RESPONSE_TIMEOUT": "500"
}
```
------
#### [ TensorFlow ]
```
"Environment": {
"SAGEMAKER_PROGRAM": "inference.py",
"SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code",
"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
"SAGEMAKER_REGION": "insert your region"
}
```
------
Se você treinou seu modelo usando SageMaker IA, especifique a variável de ambiente `SAGEMAKER_SUBMIT_DIRECTORY` como o URI completo do bucket do Amazon S3 que contém o script de treinamento.
# Implemente um modelo compilado usando o AWS CLI
Você deve atender à seção de [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) se o modelo tiver sido compilado usando AWS SDK para Python (Boto3) o console Amazon AI ou o console Amazon SageMaker AI. AWS CLI Siga as etapas abaixo para criar e implantar um modelo SageMaker compilado pelo NEO usando o. [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
**Topics**
+ [Implantar o modelo](#neo-deploy-cli)
## Implantar o modelo
Depois de satisfazer os [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), use os comandos `create-model``create-enpoint-config`, e. `create-endpoint` AWS CLI O exemplo a seguir mostra como usar esses comandos para implantar um modelo compilado com o Neo:
### Criar um modelo
Em [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), selecione o URI da imagem de inferência e use a `create-model` API para criar um modelo de SageMaker IA. Você pode fazer isso em duas etapas:
1. Crie um arquivo `create_model.json`. No arquivo, especifique o nome do modelo, o URI da imagem, o caminho para o `model.tar.gz` arquivo em seu bucket do Amazon S3 e sua função de execução de SageMaker IA:
```
{
"ModelName": "insert model name",
"PrimaryContainer": {
"Image": "insert the ECR Image URI",
"ModelDataUrl": "insert S3 archive URL",
"Environment": {"See details below"}
},
"ExecutionRoleArn": "ARN for AmazonSageMaker-ExecutionRole"
}
```
Se você treinou seu modelo usando SageMaker IA, especifique a seguinte variável de ambiente:
```
"Environment": {
"SAGEMAKER_SUBMIT_DIRECTORY" : "[Full S3 path for *.tar.gz file containing the training script]"
}
```
Se você não treinou seu modelo usando SageMaker IA, especifique as seguintes variáveis de ambiente:
------
#### [ MXNet and PyTorch ]
```
"Environment": {
"SAGEMAKER_PROGRAM": "inference.py",
"SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code",
"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
"SAGEMAKER_REGION": "insert your region",
"MMS_DEFAULT_RESPONSE_TIMEOUT": "500"
}
```
------
#### [ TensorFlow ]
```
"Environment": {
"SAGEMAKER_PROGRAM": "inference.py",
"SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code",
"SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
"SAGEMAKER_REGION": "insert your region"
}
```
------
**nota**
As políticas `AmazonSageMakerFullAccess` e `AmazonS3ReadOnlyAccess` devem ser anexadas à função IAM `AmazonSageMaker-ExecutionRole`.
1. Execute o seguinte comando:
```
aws sagemaker create-model --cli-input-json file://create_model.json
```
Para a sintaxe completa da API `create-model`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
### Criar uma configuração de endpoint
Depois de criar um modelo de SageMaker IA, crie a configuração do endpoint usando a `create-endpoint-config` API. Para fazer isso, crie um arquivo JSON com as especificações de configuração do endpoint. Por exemplo, você pode usar o seguinte modelo de código e salvá-lo como `create_config.json`:
```
{
"EndpointConfigName": "",
"ProductionVariants": [
{
"VariantName": "",
"ModelName": "my-sagemaker-model",
"InitialInstanceCount": 1,
"InstanceType": "",
"InitialVariantWeight": 1.0
}
]
}
```
Agora, execute o AWS CLI comando a seguir para criar sua configuração de endpoint:
```
aws sagemaker create-endpoint-config --cli-input-json file://create_config.json
```
Para a sintaxe completa da API `create-endpoint-config`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html).
### Criar um endpoint
Depois de criar sua configuração de endpoint, crie um endpoint usando a API `create-endpoint`:
```
aws sagemaker create-endpoint --endpoint-name '' --endpoint-config-name ''
```
Para a sintaxe completa da API `create-endpoint`, consulte [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
# Implante um modelo compilado usando o console
Você deve atender à seção de [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) se o modelo tiver sido compilado usando o console Amazon AWS SDK para Python (Boto3) AI ou o AWS CLI console do Amazon SageMaker AI. Siga as etapas abaixo para criar e implantar um modelo SageMaker AI Neo-compilado usando o console de SageMaker AI [https://console.aws.amazon.com SageMaker /AI](https://console.aws.amazon.com/sagemaker/).
**Topics**
+ [Implante o modelo](#deploy-the-model-console-steps)
## Implante o modelo
Depois de atender aos [pré-requisitos](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), use as etapas a seguir para implantar um modelo compilado com o Neo:
1. Escolha **Modelos** e depois **Criar modelos** no grupo **Inferência**. Na página **Criar modelo**, preencha os campos **Nome do modelo**,** Função do IAM** e, se necessário, **VPC** (opcional).
![\[Criar modelo Neo para inferência\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Para adicionar informações sobre o contêiner usado para implantar o modelo, selecione **Adicionar contêiner** e **Próximo**. Preencha os campos **Opções de entrada de contêiner**, **Local de imagem do código de inferência** e **Local dos artefatos do modelo** e, opcionalmente, **Nome de host do contêiner** e **Variáveis de ambiente**.
![\[Criar modelo Neo para inferência\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/neo-deploy-console-container-definition.png)
1. Para implantar modelos compilados pelo Neo, escolha o seguinte:
+ **Opções de entrada de contêiner**: escolha **Fornecer artefatos do modelo e a imagem de inferência**:
+ **Localização da imagem do código de inferência**: escolha o URI da imagem de inferência em [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), dependendo da AWS região e do tipo de aplicativo.
+ **Local dos artefatos do modelo**: insira o URI completo do bucket do S3 do artefato do modelo compilado gerado pela API de compilação do Neo.
+ **Variáveis de ambiente**:
+ Deixe esse campo em branco para **SageMaker XGBoost**.
+ Se você treinou seu modelo usando SageMaker IA, especifique a variável de ambiente `SAGEMAKER_SUBMIT_DIRECTORY` como o URI do bucket do Amazon S3 que contém o script de treinamento.
+ Se você não treinou seu modelo usando SageMaker IA, especifique as seguintes variáveis de ambiente:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/neo-deployment-hosting-services-console.html)
1. Confirme se as informações dos contêineres são precisas e, em seguida, escolha **Create model (Criar modelo)**. Na **página de destino Criar modelo**, escolha **Criar endpoint**.
![\[Página de destino de criação do modelo\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/neo-deploy-console-create-model-land-page.png)
1. No diagrama **Criar e configurar endpoint**, especifique o **Nome do endpoint**. Para **Anexar configuração do endpoint**, escolha **Criar uma nova configuração do endpoint**.
![\[Interface de usuário do console do Neo para criar e configurar o endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/neo-deploy-console-config-endpoint.png)
1. Na página **Nova configuração do endpoint**, especifique **Nome da configuração do endpoint**.
![\[Interface de usuário do console do Neo para nova configuração de endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/neo-deploy-console-new-endpoint-config.png)
1. Escolha **Editar** ao lado do nome do modelo e especifique o **Tipo de instância** correto na página **Editar variante de produção**. É imperativo que o valor de **Tipo de instância** corresponda ao especificado no trabalho de compilação.
![\[Interface de usuário do console do Neo para nova configuração de endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/neo-deploy-console-edit-production-variant.png)
1. Escolha **Save (Salvar)**.
1. Na página **Nova configuração de endpoint**, escolha **Criar configuração de endpoint** e, em seguida, escolha **Criar endpoint**.