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á.
# Instâncias de nuvem
O Amazon SageMaker Neo é compatível com frameworks de machine learning conhecidos, como TensorFlow, PyTorch, MXNet e muito mais. Você pode implantar seu modelo compilado em instâncias de nuvem e instâncias de inferência AWS. Para obter uma lista dos frameworks e dos tipos de instâncias compatíveis, consulte [Tipos de instâncias compatíveis e frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-cloud.html).
Você pode compilar seu modelo de três maneiras: por meio da AWS CLI, do console do SageMaker AI ou do SageMaker AI Python SDK. Consulte [Usar o Neo para compilar um modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation.html) para obter mais informações. Depois de compilados, os artefatos do modelo são armazenados no URI do bucket do Amazon S3 que você especificou durante o trabalho de compilação. Você pode implantar seu modelo compilado em instâncias de nuvem e instâncias de inferência da AWS usando o SageMaker AI Python SDK, o AWS SDK para Python (Boto3), a AWS CLI ou o Console da AWS.
Se você implantar seu modelo usando AWS CLI o console ou o Boto3, deverá selecionar um URI do Amazon ECR de imagem do Docker para seu contêiner principal. Consulte [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) para obter uma lista de URIs do Amazon ECR.
**Topics**
+ [
# Tipos e estruturas de instância compatíveis
](neo-supported-cloud.md)
+ [
# Implantar um modelo
](neo-deployment-hosting-services.md)
+ [
# Solicitações de inferência com um serviço implantado
](neo-requests.md)
+ [
# Imagens de contêiner de inferência
](neo-deployment-hosting-services-container-images.md)
# Tipos e estruturas de instância compatíveis
O Amazon SageMaker Neo oferece apoio a frameworks mais conhecidos de aprendizado profundo para compilação e implantação. Você pode implantar o modelo compilado em instâncias de nuvem ou tipos de instância AWS Inferentia.
A seguir, descrevemos as estruturas compatíveis com o SageMaker Neo e as instâncias de nuvem de destino nas quais você pode compilar e implantar. Para obter informações sobre como implantar seu modelo compilado em uma instância de nuvem ou Inferentia, consulte [Implantar um modelo com instâncias de nuvem](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services.html).
## Instâncias de nuvem
O SageMaker Neo é compatível com as seguintes estruturas de aprendizado profundo para instâncias de nuvem de CPU e GPU:
| Framework | Versão do framework | Versão do modelo | Modelos da | Formatos de modelo (empacotados em \$1.tar.gz) | Kits de ferramentas |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.8.0 | Compatível com 1.8.0 ou anterior | Classificação de imagens, detecção de objetos, segmentação semântica, estimativa de pose, reconhecimento de atividades | Um arquivo de símbolos (.json) e um arquivo de parâmetros (.params) | GluonCV v0.8.0 |
| ONNX | 1.7.0 | Compatível com 1.7.0 ou anterior | Classificação de imagens, SVM | Um arquivo de modelo (.onnx) | |
| Keras | 2.2.4 | Compatível com 2.2.4 ou anterior | Classificação de imagens | Um arquivo de definição de modelo (.h5) | |
| PyTorch | 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13, ou 2.0 | Compatível com 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13, e 2.0 | Classificação de imagens As versões 1.13 e 2.0 são compatíveis com Detecção de Objetos, Transformador de Visão e HuggingFace | Um arquivo de definição de modelo (.pt ou .pth) com dtype de entrada de float32 | |
| TensorFlow | 1.15.3 ou 2.9 | Compatível com 1.15.3 e 2.9 | Classificação de imagens | Para os modelos salvos, um arquivo .pb ou um arquivo .pbtxt e um diretório de variáveis que contenha variáveis Para modelos congelados, apenas um arquivo .pb ou .pbtxt | |
| XGBoost | 1.3.3 | Compatível com 1.3.3 ou anterior | Árvores de decisão | Um arquivo de modelo XGBoost (.model) em que o número de nós em uma árvore é menor que 2^31 | |
**nota**
“Versão do modelo” é a versão da estrutura usada para treinar e exportar o modelo.
## Tipos de instância
Você pode implantar seu modelo compilado do SageMaker AI em uma das instâncias de nuvem listadas abaixo:
| Instância | Tipo de computação |
| --- | --- |
| `ml_c4` | Padrão |
| `ml_c5` | Padrão |
| `ml_m4` | Padrão |
| `ml_m5` | Padrão |
| `ml_p2` | Computação acelerada |
| `ml_p3` | Computação acelerada |
| `ml_g4dn` | Computação acelerada |
Para obter informações sobre a vCPU, a memória e o preço por hora disponíveis para cada tipo de instância, consulte a [definição de preços do Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**nota**
Ao compilar para instâncias `ml_*` usando a estrutura PyTorch, use o campo de **opções do compilador** na **Configuração de saída** para fornecer o tipo de dados correto (`dtype`) da entrada do modelo.
O padrão é definido como `"float32"`.
## AWS Inferência
O SageMaker Neo é compatível com as seguintes estruturas de aprendizado profundo para Inf1:
| Framework | Versão do framework | Versão do modelo | Modelos da | Formatos de modelo (empacotados em \$1.tar.gz) | Kits de ferramentas |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.5 or 1.8 | Compatível com 1.8, 1.5 ou anterior | Classificação de imagens, detecção de objetos, segmentação semântica, estimativa de pose, reconhecimento de atividades | Um arquivo de símbolos (.json) e um arquivo de parâmetros (.params) | GluonCV v0.8.0 |
| PyTorch | 1.7, 1.8 or 1.9 | Compatível com 1.9 ou anterior | Classificação de imagens | Um arquivo de definição de modelo (.pt ou .pth) com dtype de entrada de float32 | |
| TensorFlow | 1.15 ou 2.5 | Compatível com 2.5, 1.15 ou anterior | Classificação de imagens | Para os modelos salvos, um arquivo .pb ou um arquivo .pbtxt e um diretório de variáveis que contenha variáveis Para modelos congelados, apenas um arquivo .pb ou .pbtxt | |
**nota**
“Versão do modelo” é a versão da estrutura usada para treinar e exportar o modelo.
Você pode implantar seu modelo necompilado do SageMaker em em instâncias da AWS Amazon EC2 Inf1 baseadas em inferência. O Inferentia é o primeiro chip de silício personalizado da Amazon projetado para acelerar o aprendizado profundo. Atualmente, você pode usar a instância `ml_inf1` para implantar seus modelos compilados.
### Inferentia2 da AWS e Trainium da AWS
Atualmente, você pode implantar seu modelo compilado pelo SageMaker Neo em instâncias AWS Amazon EC2 Inf2 baseadas em Inferentia2 (na região Leste dos EUA (Ohio)) e em instâncias Amazon EC2 Trn1 baseadas em AWS Trainium (na região Leste dos EUA (Norte da Virgínia)). Para obter mais informações sobre os modelos compatíveis nessas instâncias, consulte as [Diretrizes de ajuste da arquitetura de modelos](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/model-architecture-fit.html) na documentação do AWS Neuron e os exemplos no [repositório Neuron Github](https://github.com/aws-neuron/aws-neuron-sagemaker-samples).
# 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**.
# Solicitações de inferência com um serviço implantado
Se você seguiu as instruções em[Implantar um modelo](neo-deployment-hosting-services.md), você deve ter um endpoint de SageMaker IA configurado e funcionando. Independentemente de como você implantou seu modelo compilado pelo Neo, há três maneiras de enviar solicitações de inferência:
**Topics**
+ [
# Solicitar inferências de um serviço implantado (Amazon SageMaker SDK)
](neo-requests-sdk.md)
+ [
# Solicitar inferências de um serviço implantado (Boto3)
](neo-requests-boto3.md)
+ [
# Solicitar inferências de um serviço implantado (CLI AWS )
](neo-requests-cli.md)
# Solicitar inferências de um serviço implantado (Amazon SageMaker SDK)
Use os exemplos de código a seguir para solicitar inferências do seu serviço implantado com base na estrutura que você usou para treinar seu modelo. Os exemplos de código para as diferentes estruturas são semelhantes. A principal diferença é que TensorFlow exige `application/json` o tipo de conteúdo.
## PyTorch and MXNet
Se você estiver usando a versão **PyTorch 1.4 ou posterior ou** a **MXNet 1.7.0 ou posterior** e tiver um endpoint de SageMaker IA da Amazon`InService`, poderá fazer solicitações de inferência usando o `predictor` pacote do SDK de IA SageMaker para Python.
**nota**
A API varia de acordo com a versão do SageMaker AI SDK para Python:
Para a versão 1.x, use [https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor](https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor) e API [https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor.predict](https://sagemaker.readthedocs.io/en/v1.72.0/api/inference/predictors.html#sagemaker.predictor.RealTimePredictor.predict).
Para a versão 2.x, use [https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor) e API [https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor.predict](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html#sagemaker.predictor.Predictor.predict).
O exemplo de código a seguir mostra como usá-los APIs para enviar uma imagem para inferência:
------
#### [ SageMaker Python SDK v1.x ]
```
from sagemaker.predictor import RealTimePredictor
endpoint = 'insert name of your endpoint here'
# Read image into memory
payload = None
with open("image.jpg", 'rb') as f:
payload = f.read()
predictor = RealTimePredictor(endpoint=endpoint, content_type='application/x-image')
inference_response = predictor.predict(data=payload)
print (inference_response)
```
------
#### [ SageMaker Python SDK v2.x ]
```
from sagemaker.predictor import Predictor
endpoint = 'insert name of your endpoint here'
# Read image into memory
payload = None
with open("image.jpg", 'rb') as f:
payload = f.read()
predictor = Predictor(endpoint)
inference_response = predictor.predict(data=payload)
print (inference_response)
```
------
## TensorFlow
O exemplo de código a seguir mostra como usar a API SageMaker Python SDK para enviar uma imagem para inferência:
```
from sagemaker.predictor import Predictor
from PIL import Image
import numpy as np
import json
endpoint = 'insert the name of your endpoint here'
# Read image into memory
image = Image.open(input_file)
batch_size = 1
image = np.asarray(image.resize((224, 224)))
image = image / 128 - 1
image = np.concatenate([image[np.newaxis, :, :]] * batch_size)
body = json.dumps({"instances": image.tolist()})
predictor = Predictor(endpoint)
inference_response = predictor.predict(data=body)
print(inference_response)
```
# Solicitar inferências de um serviço implantado (Boto3)
Você pode enviar solicitações de inferência usando o cliente e a API do SageMaker AI SDK for Python (Boto3) depois de ter um endpoint [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint)de IA. SageMaker `InService` O seguinte exemplo de código mostra como enviar uma imagem para inferência:
------
#### [ PyTorch and MXNet ]
```
import boto3
import json
endpoint = 'insert name of your endpoint here'
runtime = boto3.Session().client('sagemaker-runtime')
# Read image into memory
with open(image, 'rb') as f:
payload = f.read()
# Send image via InvokeEndpoint API
response = runtime.invoke_endpoint(EndpointName=endpoint, ContentType='application/x-image', Body=payload)
# Unpack response
result = json.loads(response['Body'].read().decode())
```
------
#### [ TensorFlow ]
Para TensorFlow enviar uma entrada com `application/json` para o tipo de conteúdo.
```
from PIL import Image
import numpy as np
import json
import boto3
client = boto3.client('sagemaker-runtime')
input_file = 'path/to/image'
image = Image.open(input_file)
batch_size = 1
image = np.asarray(image.resize((224, 224)))
image = image / 128 - 1
image = np.concatenate([image[np.newaxis, :, :]] * batch_size)
body = json.dumps({"instances": image.tolist()})
ioc_predictor_endpoint_name = 'insert name of your endpoint here'
content_type = 'application/json'
ioc_response = client.invoke_endpoint(
EndpointName=ioc_predictor_endpoint_name,
Body=body,
ContentType=content_type
)
```
------
#### [ XGBoost ]
Para uma XGBoost inscrição, você deve enviar um texto CSV em vez disso:
```
import boto3
import json
endpoint = 'insert your endpoint name here'
runtime = boto3.Session().client('sagemaker-runtime')
csv_text = '1,-1.0,1.0,1.5,2.6'
# Send CSV text via InvokeEndpoint API
response = runtime.invoke_endpoint(EndpointName=endpoint, ContentType='text/csv', Body=csv_text)
# Unpack response
result = json.loads(response['Body'].read().decode())
```
------
Observe que o BYOM permite um tipo de conteúdo personalizado. Para obter mais informações, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
# Solicitar inferências de um serviço implantado (CLI AWS )
Solicitações de inferência podem ser feitas com o terminal Amazon AI [https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html)quando você tiver um endpoint `InService` de SageMaker IA da Amazon. Você pode fazer solicitações de inferência com o AWS Command Line Interface (AWS CLI). O seguinte exemplo de código mostra como enviar uma imagem para inferência:
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'insert name of your endpoint here' --body fileb://image.jpg --content-type=application/x-image output_file.txt
```
Um `output_file.txt` com informações sobre suas solicitações de inferência é feito se a inferência for bem-sucedida.
Para TensorFlow enviar uma entrada com `application/json` como tipo de conteúdo.
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'insert name of your endpoint here' --body fileb://input.json --content-type=application/json output_file.txt
```
# Imagens de contêiner de inferência
SageMaker O Neo agora fornece informações de URI de imagem de inferência para `ml_*` alvos. Para obter mais informações, consulte [DescribeCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeCompilationJob.html#sagemaker-DescribeCompilationJob-response-InferenceImage).
Com base no seu caso de uso, substitua a parte destacada no modelo de URI da imagem de inferência fornecido abaixo pelos valores adequados.
## SageMaker Inteligência Artificial da Amazon XGBoost
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/xgboost-neo:latest
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
## Keras
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-keras:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `2.2.4`.
Substitua *instance\$1type* por `cpu` ou `gpu`.
## MXNet
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-mxnet:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `1.8.0`.
Substitua *instance\$1type* por `cpu` ou `gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-mxnet:fx_version-instance_type-py3
```
Substitua *aws\$1region* por `us-east-1` ou `us-west-2`.
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `1.5.1`.
Substitua *`instance_type`* por `inf`.
------
## ONNX
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-onnx:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `1.5.0`.
Substitua *instance\$1type* por `cpu` ou `gpu`.
## PyTorch
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-pytorch:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
*fx\$1version*Substitua por `1.4` `1.5``1.6`,`1.7`,,`1.8`,`1.12`,`1.13`, ou`2.0`.
Substitua *instance\$1type* por `cpu` ou `gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-pytorch:fx_version-instance_type-py3
```
Substitua *aws\$1region* por `us-east-1` ou `us-west-2`.
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `1.5.1`.
Substitua *`instance_type`* por `inf`.
------
#### [ Inferentia2 and Trainium1 ]
```
763104351884.dkr.ecr.aws_region.amazonaws.com/pytorch-inference-neuronx:1.13.1-neuronx-py38-sdk2.10.0-ubuntu20.04
```
*aws\$1region*Substitua `us-east-2` por Inferentia2 e `us-east-1` por Trainium1.
------
## TensorFlow
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-tensorflow:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou.
Substitua *fx\$1version* por `1.15.3` ou `2.9`.
Substitua *instance\$1type* por `cpu` ou `gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-tensorflow:fx_version-instance_type-py3
```
Substitua *aws\$1account\$1id* da tabela no final desta página com base no *aws\$1region* que você usou. Observe que para tipos de instância `inf` apenas `us-east-1` e `us-west-2` são compatíveis.
Substituir *fx\$1version* por `1.15.0`
Substitua *instance\$1type* por `inf`.
------
#### [ Inferentia2 and Trainium1 ]
```
763104351884.dkr.ecr.aws_region.amazonaws.com/tensorflow-inference-neuronx:2.10.1-neuronx-py38-sdk2.10.0-ubuntu20.04
```
*aws\$1region*Substitua `us-east-2` por Inferentia2 e `us-east-1` por Trainium1.
------
A tabela a seguir mapeia *aws\$1account\$1id* com*aws\$1region*. Use essa tabela para encontrar o URI correto da imagem de inferência que você precisa para sua aplicação.
| aws\$1account\$1id | aws\$1region |
| --- | --- |
| 785573368785 | us-east-1 |
| 00:7: 39, 36,8137 | us-east-2 |
| 710691900526 | us-west-1 |
| 301217895009 | us-west-2 |
| 802834080501 | eu-west-1 |
| 205493899709 | eu-west-2 |
| 254080097072 | eu-west-3 |
| 601324751636 | eu-north-1 |
| 966458181534 | eu-south-1 |
| 746233611703 | eu-central-1 |
| 110948597952 | ap-east-1 |
| 763008648453 | ap-south-1 |
| 941853720454 | ap-northeast-1 |
| 151534178276 | ap-northeast-2 |
| 925152966179 | ap-northeast-3 |
| 324986816169 | ap-southeast-1 |
| 355873309152 | ap-southeast-2 |
| 474822919863 | cn-northwest-1 |
| 472730292857 | cn-north-1 |
| 756306329178 | sa-east-1 |
| 464438896020 | ca-central-1 |
| 836785723513 | me-south-1 |
| 774647643957 | af-south-1 |
| 275950707576 | il-central-1 |