Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menyebarkan Model
Untuk menerapkan model yang SageMaker dikompilasi Amazon Neo ke titik akhir HTTPS, Anda harus mengonfigurasi dan membuat titik akhir untuk model menggunakan layanan hosting Amazon AI. SageMaker Saat ini, pengembang dapat menggunakan Amazon SageMaker APIs untuk menyebarkan modul ke instance ml.c5, ml.c4, ml.m5, ml.m4, ml.p3, ml.p2, dan ml.inf1.
Untuk instance [Inferentia](https://aws.amazon.com/machine-learning/inferentia/) dan [Trainium](https://aws.amazon.com/machine-learning/trainium/), model perlu dikompilasi secara khusus untuk instance tersebut. Model yang dikompilasi untuk jenis instance lain tidak dijamin berfungsi dengan instans Inferentia atau Trainium.
Saat menerapkan model yang dikompilasi, Anda perlu menggunakan instance yang sama untuk target yang Anda gunakan untuk kompilasi. Ini menciptakan titik akhir SageMaker AI yang dapat Anda gunakan untuk melakukan inferensi. [Anda dapat menerapkan model yang dikompilasi NEO menggunakan salah satu dari berikut ini: [Amazon SageMaker AI SDK untuk Python, SDK for](https://sagemaker.readthedocs.io/en/stable/)[Python (Boto3),](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) dan konsol AI. [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/reference/)SageMaker ](https://console.aws.amazon.com/sagemaker)
**catatan**
Untuk menerapkan model menggunakan AWS CLI, konsol, atau Boto3, lihat [Neo Inference Container Images untuk memilih URI gambar inferensi untuk container](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) utama Anda.
**Topics**
+ [Prasyarat](neo-deployment-hosting-services-prerequisites.md)
+ [Menerapkan Model Terkompilasi Menggunakan SageMaker SDK](neo-deployment-hosting-services-sdk.md)
+ [Menyebarkan Model Kompilasi Menggunakan Boto3](neo-deployment-hosting-services-boto3.md)
+ [Menerapkan Model Kompilasi Menggunakan AWS CLI](neo-deployment-hosting-services-cli.md)
+ [Menerapkan Model Kompilasi Menggunakan Konsol](neo-deployment-hosting-services-console.md)
# Prasyarat
**catatan**
Ikuti petunjuk di bagian ini jika Anda mengkompilasi model menggunakan AWS SDK untuk Python (Boto3), AWS CLI, atau konsol SageMaker AI.
Untuk membuat model yang SageMaker dikompilasi NEO, Anda memerlukan yang berikut ini:
1. Gambar Docker Amazon ECR URI. Anda dapat memilih salah satu yang memenuhi kebutuhan Anda dari [daftar ini](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html).
1. File skrip titik masuk:
1. **Untuk PyTorch dan MXNet model:**
*Jika Anda melatih model Anda menggunakan SageMaker AI*, skrip pelatihan harus mengimplementasikan fungsi yang dijelaskan di bawah ini. Skrip pelatihan berfungsi sebagai skrip titik masuk selama inferensi. Dalam contoh yang dirinci dalam [Pelatihan MNIST, Kompilasi dan Penerapan dengan MXNet Modul dan SageMaker Neo](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_neo_compilation_jobs/mxnet_mnist/mxnet_mnist_neo.html), skrip pelatihan (`mnist.py`) mengimplementasikan fungsi yang diperlukan.
*Jika Anda tidak melatih model Anda menggunakan SageMaker AI*, Anda perlu menyediakan file entry point script (`inference.py`) yang dapat digunakan pada saat inferensi. [Berdasarkan kerangka kerja— MXNet atau PyTorch —lokasi skrip inferensi harus sesuai dengan Struktur Direktori Model SDK SageMaker Python untuk atau [Struktur Direktori Model untuk MxNet](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)
Saat menggunakan gambar Neo Inference Optimized Container dengan **PyTorch**dan **MXNet**pada tipe instance CPU dan GPU, skrip inferensi harus mengimplementasikan fungsi-fungsi berikut:
+ `model_fn`: Memuat model. (Opsional)
+ `input_fn`: Mengkonversi payload permintaan masuk ke array numpy.
+ `predict_fn`: Melakukan prediksi.
+ `output_fn`: Mengkonversi output prediksi ke payload respon.
+ Atau, Anda dapat menentukan `transform_fn` untuk menggabungkan`input_fn`,`predict_fn`, dan`output_fn`.
Berikut ini adalah contoh `inference.py` skrip dalam direktori bernama `code` (`code/inference.py`) untuk **PyTorch dan MXNet (Gluon dan Modul)**. Contoh pertama memuat model dan kemudian menyajikannya pada data gambar pada 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. **Untuk instance inf1 atau onnx, xgboost, gambar kontainer keras**
Untuk semua gambar kontainer yang dioptimalkan Neo Inference lainnya, atau jenis instance inferentia, skrip titik masuk harus mengimplementasikan fungsi berikut untuk Neo Deep Learning Runtime:
+ `neo_preprocess`: Mengkonversi payload permintaan masuk ke array numpy.
+ `neo_postprocess`: Mengonversi output prediksi dari Neo Deep Learning Runtime menjadi badan respons.
**catatan**
Dua fungsi sebelumnya tidak menggunakan salah satu fungsi, MXNet, PyTorch atau. TensorFlow
Untuk contoh cara menggunakan fungsi-fungsi ini, lihat [Notebook Contoh Kompilasi Model Neo](https://docs.aws.amazon.com//sagemaker/latest/dg/neo.html#neo-sample-notebooks).
1. **Untuk TensorFlow model**
Jika model Anda memerlukan logika pra-dan pasca-pemrosesan khusus sebelum data dikirim ke model, maka Anda harus menentukan `inference.py` file skrip titik masuk yang dapat digunakan pada saat inferensi. Script harus mengimplementasikan baik sepasang `input_handler` dan `output_handler` fungsi atau fungsi handler tunggal.
**catatan**
Perhatikan bahwa jika fungsi handler diimplementasikan, `input_handler` dan `output_handler` diabaikan.
Berikut ini adalah contoh kode `inference.py` skrip yang dapat Anda kumpulkan dengan model kompilasi untuk melakukan pra-dan sesudah pemrosesan khusus pada model klasifikasi gambar. Klien SageMaker AI mengirimkan file gambar sebagai tipe `application/x-image` konten ke `input_handler` fungsi, di mana ia dikonversi ke JSON. File gambar yang dikonversi kemudian dikirim ke [Tensorflow Model Server (TFX)](https://www.tensorflow.org/tfx/serving/api_rest) menggunakan REST API.
```
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
```
Jika tidak ada pra-atau pasca-pemrosesan khusus, klien SageMaker AI mengonversi gambar file ke JSON dengan cara yang sama sebelum mengirimnya ke titik akhir AI. SageMaker
Untuk informasi selengkapnya, lihat [Deploying to TensorFlow Serving Endpoints di Python SageMaker SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#providing-python-scripts-for-pre-pos-processing).
1. URI bucket Amazon S3 yang berisi artefak model yang dikompilasi.
# Menerapkan Model Terkompilasi Menggunakan SageMaker SDK
Anda harus memenuhi bagian [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) jika model dikompilasi menggunakan AWS SDK untuk Python (Boto3),, AWS CLI atau konsol Amazon AI. SageMaker Ikuti salah satu kasus penggunaan berikut untuk menerapkan model yang dikompilasi dengan SageMaker Neo berdasarkan cara Anda mengkompilasi model Anda.
**Topics**
+ [Jika Anda mengkompilasi model menggunakan SageMaker SDK](#neo-deployment-hosting-services-sdk-deploy-sm-sdk)
+ [Jika Anda mengkompilasi model Anda menggunakan MXNet atau PyTorch](#neo-deployment-hosting-services-sdk-deploy-sm-boto3)
+ [Jika Anda mengkompilasi model Anda menggunakan Boto3, SageMaker konsol, atau CLI untuk TensorFlow](#neo-deployment-hosting-services-sdk-deploy-sm-boto3-tensorflow)
## Jika Anda mengkompilasi model menggunakan SageMaker SDK
Pegangan objek [SageMaker.model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model) untuk model yang dikompilasi menyediakan fungsi [deploy ()](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model#sagemaker.model.Model.deploy), yang memungkinkan Anda membuat titik akhir untuk menyajikan permintaan inferensi. Fungsi ini memungkinkan Anda mengatur jumlah dan jenis instance yang digunakan untuk titik akhir. Anda harus memilih contoh yang telah Anda kompilasi model Anda. Misalnya, dalam pekerjaan yang dikompilasi di bagian [Compile a Model (Amazon SageMaker SDK)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation-sagemaker-sdk.html), ini adalah. `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)
```
## Jika Anda mengkompilasi model Anda menggunakan MXNet atau PyTorch
Buat model SageMaker AI dan terapkan menggunakan deploy () API di bawah Model khusus kerangka kerja. APIs Karena MXNet, itu adalah [MXNetModel](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html?highlight=MXNetModel#mxnet-model) dan untuk PyTorch, itu [ PyTorchModel](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html?highlight=PyTorchModel#sagemaker.pytorch.model.PyTorchModel). Saat membuat dan menerapkan model SageMaker AI, Anda harus menyetel variabel `MMS_DEFAULT_RESPONSE_TIMEOUT` lingkungan ke `500` dan menentukan `entry_point` parameter sebagai skrip inferensi (`inference.py`) dan `source_dir` parameter sebagai lokasi direktori (`code`) dari skrip inferensi. Untuk menyiapkan skrip inferensi (`inference.py`) ikuti langkah Prasyarat.
Contoh berikut menunjukkan cara menggunakan fungsi-fungsi ini untuk menerapkan model yang dikompilasi menggunakan SageMaker AI SDK untuk 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)
```
------
**catatan**
`AmazonS3ReadOnlyAccess`Kebijakan `AmazonSageMakerFullAccess` dan kebijakan harus dilampirkan pada peran `AmazonSageMaker-ExecutionRole` IAM.
## Jika Anda mengkompilasi model Anda menggunakan Boto3, SageMaker konsol, atau CLI untuk TensorFlow
Buat `TensorFlowModel` objek, lalu panggil deploy:
```
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)
```
Lihat [Menerapkan langsung dari artefak model untuk informasi](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#deploying-directly-from-model-artifacts) selengkapnya.
Anda dapat memilih gambar Docker Amazon ECR URI yang memenuhi kebutuhan Anda dari daftar [ini](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html).
Untuk informasi selengkapnya tentang cara membuat `TensorFlowModel` objek, lihat [SageMaker SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-serving-model).
**catatan**
Permintaan inferensi pertama Anda mungkin memiliki latensi tinggi jika Anda menerapkan model Anda pada GPU. Ini karena kernel komputasi yang dioptimalkan dibuat pada permintaan inferensi pertama. Kami menyarankan Anda membuat file pemanasan permintaan inferensi dan menyimpannya di samping file model Anda sebelum mengirimkannya ke TFX. Ini dikenal sebagai “pemanasan” model.
[Cuplikan kode berikut menunjukkan cara menghasilkan file pemanasan untuk contoh klasifikasi gambar di bagian prasyarat:](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())
```
Untuk informasi lebih lanjut tentang cara “menghangatkan” model Anda, lihat [halaman TensorFlow TFX](https://www.tensorflow.org/tfx/serving/saved_model_warmup).
# Menyebarkan Model Kompilasi Menggunakan Boto3
Anda harus memenuhi bagian [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) jika model dikompilasi menggunakan AWS SDK untuk Python (Boto3),, AWS CLI atau konsol Amazon AI. SageMaker Ikuti langkah-langkah di bawah ini untuk membuat dan menerapkan model yang SageMaker dikompilasi NEO menggunakan [Amazon Web Services SDK for Python (Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)).
**Topics**
+ [Menyebarkan Model](#neo-deployment-hosting-services-boto3-steps)
## Menyebarkan Model
Setelah Anda memenuhi [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), gunakan,, dan`create_model`. `create_enpoint_config` `create_endpoint` APIs
Contoh berikut menunjukkan cara menggunakan ini APIs untuk menyebarkan model yang dikompilasi dengan 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)
```
**catatan**
`AmazonS3ReadOnlyAccess`Kebijakan `AmazonSageMakerFullAccess` dan kebijakan harus dilampirkan pada peran `AmazonSageMaker-ExecutionRole` IAM.
Untuk sintaks lengkap`create_model`,`create_endpoint_config`, dan `create_endpoint` APIs, lihat [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), [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), dan [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), masing-masing.
Jika Anda tidak melatih model Anda menggunakan SageMaker AI, tentukan variabel lingkungan berikut:
------
#### [ 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"
}
```
------
Jika Anda melatih model menggunakan SageMaker AI, tentukan variabel lingkungan `SAGEMAKER_SUBMIT_DIRECTORY` sebagai URI bucket Amazon S3 lengkap yang berisi skrip pelatihan.
# Menerapkan Model Kompilasi Menggunakan AWS CLI
Anda harus memenuhi bagian [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) jika model dikompilasi menggunakan AWS SDK untuk Python (Boto3),, AWS CLI atau konsol Amazon AI. SageMaker Ikuti langkah-langkah di bawah ini untuk membuat dan menerapkan model yang SageMaker dikompilasi NEO menggunakan. [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
**Topics**
+ [Menyebarkan Model](#neo-deploy-cli)
## Menyebarkan Model
Setelah Anda memenuhi [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), gunakan,, dan perintah`create-model`. `create-enpoint-config` `create-endpoint` AWS CLI Langkah-langkah berikut menjelaskan cara menggunakan perintah ini untuk menyebarkan model yang dikompilasi dengan Neo:
### Buat Model
Dari [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), pilih URI gambar inferensi dan kemudian gunakan `create-model` API untuk membuat model SageMaker AI. Anda dapat melakukan ini dengan dua langkah:
1. Buat `create_model.json` file. Di dalam file, tentukan nama model, URI gambar, jalur ke `model.tar.gz` file di bucket Amazon S3, dan peran eksekusi SageMaker AI Anda:
```
{
"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"
}
```
Jika Anda melatih model Anda menggunakan SageMaker AI, tentukan variabel lingkungan berikut:
```
"Environment": {
"SAGEMAKER_SUBMIT_DIRECTORY" : "[Full S3 path for *.tar.gz file containing the training script]"
}
```
Jika Anda tidak melatih model Anda menggunakan SageMaker AI, tentukan variabel lingkungan berikut:
------
#### [ 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"
}
```
------
**catatan**
`AmazonS3ReadOnlyAccess`Kebijakan `AmazonSageMakerFullAccess` dan kebijakan harus dilampirkan pada peran `AmazonSageMaker-ExecutionRole` IAM.
1. Jalankan perintah berikut:
```
aws sagemaker create-model --cli-input-json file://create_model.json
```
Untuk sintaks lengkap `create-model` API, lihat [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
### Buat Konfigurasi Endpoint
Setelah membuat model SageMaker AI, buat konfigurasi titik akhir menggunakan `create-endpoint-config` API. Untuk melakukan ini, buat file JSON dengan spesifikasi konfigurasi titik akhir Anda. Misalnya, Anda dapat menggunakan template kode berikut dan menyimpannya sebagai`create_config.json`:
```
{
"EndpointConfigName": "",
"ProductionVariants": [
{
"VariantName": "",
"ModelName": "my-sagemaker-model",
"InitialInstanceCount": 1,
"InstanceType": "",
"InitialVariantWeight": 1.0
}
]
}
```
Sekarang jalankan AWS CLI perintah berikut untuk membuat konfigurasi endpoint Anda:
```
aws sagemaker create-endpoint-config --cli-input-json file://create_config.json
```
Untuk sintaks lengkap `create-endpoint-config` API, lihat [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).
### Buat Endpoint
Setelah Anda membuat konfigurasi titik akhir, buat titik akhir menggunakan API: `create-endpoint`
```
aws sagemaker create-endpoint --endpoint-name '' --endpoint-config-name ''
```
Untuk sintaks lengkap `create-endpoint` API, lihat [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
# Menerapkan Model Kompilasi Menggunakan Konsol
Anda harus memenuhi bagian [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) jika model dikompilasi menggunakan AWS SDK untuk Python (Boto3), konsol, AWS CLI atau Amazon AI. SageMaker [Ikuti langkah-langkah di bawah ini untuk membuat dan menerapkan model yang dikompilasi SageMaker AI Neo menggunakan konsol SageMaker https://console.aws.amazon.com AI/AI. SageMaker ](https://console.aws.amazon.com/sagemaker/)
**Topics**
+ [Menyebarkan Model](#deploy-the-model-console-steps)
## Menyebarkan Model
Setelah Anda memenuhi [prasyarat](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), gunakan langkah-langkah berikut untuk menerapkan model yang dikompilasi dengan Neo:
1. Pilih **Model**, lalu pilih **Buat model** dari grup **Inferensi**. Pada halaman **Buat model**, lengkapi **nama Model**, **peran IAM**, dan bidang **VPC** (opsional), jika diperlukan.
![\[Buat model Neo untuk inferensi\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Untuk menambahkan informasi tentang kontainer yang digunakan untuk menyebarkan model Anda, pilih **Tambahkan kontainer kontainer**, lalu pilih **Berikutnya**. Lengkapi **opsi input Container**, **Lokasi gambar kode inferensi**, dan **Lokasi artefak model**, dan opsional, **nama host kontainer**, dan bidang variabel **Lingkungan**.
![\[Buat model Neo untuk inferensi\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/neo-deploy-console-container-definition.png)
1. Untuk menerapkan model yang dikompilasi NEO, pilih yang berikut ini:
+ **Opsi input kontainer**: Pilih **Berikan artefak model dan gambar inferensi**.
+ **Lokasi gambar kode inferensi: Pilih URI gambar** inferensi dari [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), tergantung pada AWS Wilayah dan jenis aplikasi.
+ **Lokasi artefak model**: Masukkan URI bucket Amazon S3 dari artefak model terkompilasi yang dihasilkan oleh API kompilasi Neo.
+ **Variabel lingkungan**:
+ Biarkan bidang ini kosong untuk **SageMaker XGBoost**.
+ Jika Anda melatih model menggunakan SageMaker AI, tentukan variabel lingkungan `SAGEMAKER_SUBMIT_DIRECTORY` sebagai URI bucket Amazon S3 yang berisi skrip pelatihan.
+ Jika Anda tidak melatih model Anda menggunakan SageMaker AI, tentukan variabel lingkungan berikut:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/neo-deployment-hosting-services-console.html)
1. Konfirmasikan bahwa informasi untuk kontainer akurat, lalu pilih **Buat model**. Pada **halaman landing Create model**, pilih **Create endpoint**.
![\[Buat halaman arahan Model\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/neo-deploy-console-create-model-land-page.png)
1. Di **Buat dan konfigurasikan diagram titik akhir**, tentukan nama **Endpoint**. Untuk **konfigurasi Attach endpoint**, pilih **Create a new endpoint** configuration.
![\[Konsol Neo membuat dan mengonfigurasi UI titik akhir.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/neo-deploy-console-config-endpoint.png)
1. Di halaman **konfigurasi titik akhir baru**, tentukan nama **konfigurasi Endpoint**.
![\[UI konfigurasi titik akhir baru konsol Neo.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/neo-deploy-console-new-endpoint-config.png)
1. Pilih **Edit** di samping nama model dan tentukan **jenis Instance** yang benar pada halaman **Edit Production Variant**. Sangat penting bahwa nilai **tipe Instance** cocok dengan yang ditentukan dalam pekerjaan kompilasi Anda.
![\[UI konfigurasi titik akhir baru konsol Neo.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/neo-deploy-console-edit-production-variant.png)
1. Pilih **Simpan**.
1. Pada halaman **konfigurasi titik akhir baru**, pilih **Buat konfigurasi titik akhir**, lalu pilih **Buat** titik akhir.