Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Cloud\$1Instances
Amazon SageMaker Neo bietet Kompilierungsunterstützung für verbreitete Machine-Learning-Frameworks wie TensorFlow, PyTorch, MXNet und mehr. Sie können Ihr kompiliertes Modell auf Cloud-Instances und AWS Inferentia-Instances bereitstellen. Eine Liste der unterstützten Frameworks und Instance-Typen finden Sie unter [Unterstützte Instance-Typen und Frameworks](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-supported-cloud.html).
Sie können Ihr Modell auf drei Arten kompilieren: über die AWS CLI, die SageMaker-AI-Konsole oder das SageMaker AI SDK für Python. Weitere Informationen finden Sie unter [Verwenden von Neo zum Kompilieren eines Modells](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation.html). Nach der Kompilierung werden Ihre Modellartefakte in der Amazon-S3-Bucket-URI gespeichert, die Sie während des Kompilierungsjobs angegeben haben. Sie können Ihr kompiliertes Modell mithilfe des SageMaker AI SDK für Python, AWS SDK für Python (Boto3), AWS CLI oder der AWS-Konsole auf Cloud-Instances und AWS-Inferentia-Instances bereitstellen.
Wenn Sie Ihr Modell mithilfe AWS CLI der Konsole oder mit Boto3 bereitstellen, müssen Sie einen Amazon ECR-URI für das Docker-Image für Ihren primären Container auswählen. Eine Liste der Amazon ECR-URIs finden Sie unter [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html).
**Topics**
+ [Unterstützte Instance-Typen und Frameworks](neo-supported-cloud.md)
+ [Bereitstellen eines Modells](neo-deployment-hosting-services.md)
+ [Inferenzanfragen mit einem bereitgestellten Dienst](neo-requests.md)
+ [Inferenzcontainer-Bilder](neo-deployment-hosting-services-container-images.md)
# Unterstützte Instance-Typen und Frameworks
Amazon SageMaker Neo unterstützt beliebte Deep-Learning-Frameworks sowohl für die Kompilierung als auch für die Bereitstellung. Sie können Ihr Modell auf Cloud-Instances oder AWS-Inferentia-Instances bereitstellen.
Im Folgenden werden die von SageMaker Neo unterstützten Frameworks und die Ziel-Cloud-Instances beschrieben, auf denen Sie kompilieren und bereitstellen können. Informationen zur Bereitstellung Ihres kompilierten Modells in einer Cloud- oder Inferentia-Instace finden Sie unter [Bereitstellen eines Modells mit Cloud-Instances](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services.html).
## Cloud-Instances
SageMaker Neo unterstützt die folgenden Deep-Learning-Frameworks für CPU- und GPU-Cloud-Instances:
| Framework | Framework-Version | Modellversion | Modelle | Modellformate (in \$1.tar.gz verpackt) | Toolkits |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.8.0 | Unterstützt 1.8.0 oder früher | Image-Klassifizierung, Objekterkennung, semantische Segmentierung, Posenschätzung, Aktivitätserkennung | MXNET: Neo erwartet eine einzelne Symboldatei (.json) und eine einzelne Parameterdatei (.params) | GluonCV v0.8.0 |
| ONNX | 1.7.0 | Unterstützt 1.7.0 oder früher | Image-Klassifizierung, SVM | Eine Modelldatei (.onnx) | |
| Keras | 2.2.4 | Unterstützt 2.2.4 oder früher | Bildklassifizierung | Eine Modelldefinitionsdatei (.h5) | |
| PyTorch | 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13 oder 2.0 | Unterstützt 1.4, 1.5, 1.6, 1.7, 1.8, 1.12, 1.13 und 2.0 | Bildklassifizierung Die Versionen 1.13 und 2.0 unterstützen Objekterkennung, Vision-Transformierung und HuggingFace | Eine Modelldefinitionsdatei (.pt oder .pth) mit dem Eingabetyp dtype von float32 | |
| TensorFlow | 1.15.3 oder 2.9 | Unterstützt 1.15.3 und 2.9 | Bildklassifizierung | Für gespeicherte Modelle eine .pb- oder eine .pbtxt-Datei und ein Variablenverzeichnis, das Variablen enthält Bei gefrorenen Modellen nur eine .pb- oder .pbtxt-Datei | |
| XGBoost | 1.3.3 | Unterstützt 1.3.3 oder früher | Entscheidungsbäume | Eine XGBoost-Modelldatei (.model), in der die Anzahl der Knoten in einem Baum weniger als 2^31 beträgt | |
**Anmerkung**
„Modellversion“ ist die Version des Frameworks, das zum Trainieren und Exportieren des Modells verwendet wird.
## Instance-Typen
Sie können Ihr mit SageMaker AI kompiliertes Modell auf einer der unten aufgeführten Cloud-Instances bereitstellen:
| Instance | Datenverarbeitungstyp |
| --- | --- |
| `ml_c4` | Standard |
| `ml_c5` | Standard |
| `ml_m4` | Standard |
| `ml_m5` | Standard |
| `ml_p2` | Beschleunigtes Computing |
| `ml_p3` | Beschleunigtes Computing |
| `ml_g4dn` | Beschleunigtes Computing |
Informationen zur verfügbaren vCPU, zum Arbeitsspeicher und zum Preis pro Stunde für jeden Instance-Typ finden Sie unter [Amazon SageMaker-Preisgestaltung](https://aws.amazon.com/sagemaker/pricing/).
**Anmerkung**
Verwenden Sie beim Kompilieren für `ml_*` Instances mit dem PyTorch-Framework das Feld **Datenverarbeitungsoptionen** in der **Ausgabekonfiguration**, um den richtigen Datentyp (`dtype`) der Modelleingabe anzugeben.
Der Standard ist auf `"float32"` gesetzt.
## AWS Inferentia
SageMaker Neo unterstützt die folgenden Deep-Learning-Frameworks für Inf1:
| Framework | Framework-Version | Modellversion | Modelle | Modellformate (in \$1.tar.gz verpackt) | Toolkits |
| --- | --- | --- | --- | --- | --- |
| MXNet | 1.5 oder 1.8 | Unterstützt 1.8, 1.5 und früher | Bildklassifizierung, Objekterkennung, semantische Segmentierung, Posenschätzung, Aktivitätserkennung | MXNET: Neo erwartet eine einzelne Symboldatei (.json) und eine einzelne Parameterdatei (.params) | GluonCV v0.8.0 |
| PyTorch | 1.7, 1.8 oder 1.9 | Unterstützt 1.9 und früher | Bildklassifizierung | Eine Modelldefinitionsdatei (.pt oder .pth) mit dem Eingabetyp dtype von float32 | |
| TensorFlow | 1.15 oder 2.5 | Unterstützt 2.5, 1.15 und früher | Bildklassifizierung | Für gespeicherte Modelle eine .pb- oder eine .pbtxt-Datei und ein Variablenverzeichnis, das Variablen enthält Bei gefrorenen Modellen nur eine .pb- oder .pbtxt-Datei | |
**Anmerkung**
„Modellversion“ ist die Version des Frameworks, das zum Trainieren und Exportieren des Modells verwendet wird.
Sie können Ihr mit SageMaker Neo kompiliertes Modell auf AWS Inferentia-basierten Amazon-EC2-Inf1-Instances bereitstellen. AWS Inferentia ist der erste kundenspezifische Siliziumchip von Amazon, der Deep Learning beschleunigen soll. Derzeit können Sie die `ml_inf1` Instance verwenden, um Ihre kompilierten Modelle bereitzustellen.
### AWS Inferentia2 und AWS Trainium
Derzeit können Sie Ihr mit SageMaker Neo kompiliertes Modell auf Inferentia2-basierten Amazon-EC2-Inf2-Instances (in der Region USA Ost (Ohio) von AWS und auf Trainium-basierten Amazon-EC2-Trn1-Instances (in der Region USA Ost (Nord-Virginia) von AWS bereitstellen. Weitere Informationen zu den unterstützten Modellen auf diesen Instances finden Sie unter [Model Architecture Fit Richtlinien](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/arch/model-architecture-fit.html) in der AWS-Neuron-Dokumentation und in den Beispielen im [Neuron Github-Repository](https://github.com/aws-neuron/aws-neuron-sagemaker-samples).
# Bereitstellen eines Modells
Um ein von Amazon SageMaker Neo kompiliertes Modell auf einem HTTPS-Endpunkt bereitzustellen, müssen Sie den Endpunkt für das Modell mithilfe der Amazon SageMaker AI-Hosting-Services konfigurieren und erstellen. Derzeit können Entwickler Amazon verwenden, SageMaker APIs um Module auf ml.c5-, ml.c4-, ml.m5-, ml.m4-, ml.p3-, ml.p2- und ml.inf1-Instances bereitzustellen.
Für [Inferentia](https://aws.amazon.com/machine-learning/inferentia/)- und [Trainium](https://aws.amazon.com/machine-learning/trainium/)-Instances müssen die Modelle speziell für diese Instances kompiliert werden. Modelle, die für andere Instance-Typen kompiliert wurden, funktionieren nicht garantiert mit Inferentia- oder Trainium-Instances.
Wenn Sie ein kompiliertes Modell bereitstellen, müssen Sie für das Ziel die gleiche Instance verwenden, die Sie auch für die Kompilierung verwendet haben. Dadurch SageMaker wird ein KI-Endpunkt erstellt, mit dem Sie Schlussfolgerungen ziehen können. [Sie können ein NEO-kompiliertes Modell mit einer der folgenden Optionen bereitstellen: [Amazon SageMaker AI SDK für Python](https://sagemaker.readthedocs.io/en/stable/), [SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) und die SageMaker AI-Konsole. [AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/reference/)](https://console.aws.amazon.com/sagemaker)
**Anmerkung**
Informationen zur Bereitstellung eines Modells mithilfe AWS CLI der Konsole oder Boto3 finden Sie unter [Neo Inference Container Images, um den Inferenz-Image-URI für Ihren primären Container](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) auszuwählen.
**Topics**
+ [Voraussetzungen](neo-deployment-hosting-services-prerequisites.md)
+ [Stellen Sie ein kompiliertes Modell mithilfe des SDK SageMaker bereit](neo-deployment-hosting-services-sdk.md)
+ [Stellen Sie ein kompiliertes Modell mit Boto3 bereit](neo-deployment-hosting-services-boto3.md)
+ [Stellen Sie ein kompiliertes Modell mit dem bereit AWS CLI](neo-deployment-hosting-services-cli.md)
+ [Stellen Sie ein kompiliertes Modell mithilfe der Konsole bereit](neo-deployment-hosting-services-console.md)
# Voraussetzungen
**Anmerkung**
Folgen Sie den Anweisungen in diesem Abschnitt, wenn Sie Ihr Modell mit AWS SDK für Python (Boto3), AWS CLI oder der AI-Konsole kompiliert haben. SageMaker
Um ein SageMaker NEO-kompiliertes Modell zu erstellen, benötigen Sie Folgendes:
1. Ein Amazon ECR-URI für ein Docker-Image. Sie können aus [dieser Liste](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) eine auswählen, die Ihren Anforderungen entspricht.
1. Eine Eintrittspunkt-Skriptdatei:
1. **Für PyTorch und MXNet Modelle:**
*Wenn Sie Ihr Modell mit SageMaker KI trainiert* haben, muss das Trainingsskript die unten beschriebenen Funktionen implementieren. Das Trainingsskript dient als Einstiegsskript für Inferenzen. In dem in [MNIST Training, Compilation and Deployment with MXNet Module and SageMaker Neo](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_neo_compilation_jobs/mxnet_mnist/mxnet_mnist_neo.html) beschriebenen Beispiel implementiert das Trainingsskript (`mnist.py`) die erforderlichen Funktionen.
*Wenn Sie Ihr Modell nicht mit SageMaker KI trainiert* haben, müssen Sie eine Einstiegspunkt-Skriptdatei (`inference.py`) bereitstellen, die zum Zeitpunkt der Inferenz verwendet werden kann. Basierend auf dem Framework — MXNet oder PyTorch — muss der Speicherort des Inferenzskripts der SageMaker Python SDK [Model Directory Structure for MxNet oder [Model Directory Structure](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#model-directory-structure) for](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#model-directory-structure) entsprechen. PyTorch
Bei der Verwendung von Neo Inference Optimized Container-Images mit **PyTorch**und **MXNet**auf CPU- und GPU-Instanztypen muss das Inferenzskript die folgenden Funktionen implementieren:
+ `model_fn`: Lädt das Modell. (Optional)
+ `input_fn`: Konvertiert die Nutzdaten der eingehenden Anfrage in ein Numpy-Array.
+ `predict_fn`: Führt die Vorhersage durch.
+ `output_fn`: Konvertiert die Vorhersageausgabe in die Antwortnutzlast.
+ Alternativ können Sie `transform_fn` so definieren, dass `input_fn`, `predict_fn` und `output_fn` kombiniert werden sollen.
Im Folgenden finden Sie Beispiele für `inference.py` Skripte in einem Verzeichnis mit dem Namen `code` (`code/inference.py`) für **PyTorch und MXNet (Gluon und Module**). Die Beispiele laden zuerst das Modell und stellen es dann für Bilddaten auf einer GPU bereit:
------
#### [ 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. **Für inf1-Instances oder Onnx-, Xgboost- und Keras-Container-Images**
Für alle anderen für Neo Inference optimierten Container-Images oder Inferentia-Instance-Typen muss das Eingangspunkt-Skript die folgenden Funktionen für Neo Deep Learning Laufzeit implementieren:
+ `neo_preprocess`: Konvertiert die Nutzdaten der eingehenden Anfrage in ein Numpy-Array.
+ `neo_postprocess`: Konvertiert die Vorhersageausgabe von Neo Deep Learning Laufzeit in den Antworttext.
**Anmerkung**
Die beiden vorherigen Funktionen verwenden keine der Funktionen von MXNet PyTorch, oder TensorFlow.
Beispiele für die Verwendung dieser Funktionen finden Sie unter [Neo Model Compilation Sample Notebooks](https://docs.aws.amazon.com//sagemaker/latest/dg/neo.html#neo-sample-notebooks).
1. **Für TensorFlow Modelle**
Wenn Ihr Modell eine benutzerdefinierte Vor- und Nachverarbeitungslogik erfordert, bevor Daten an das Modell gesendet werden, müssen Sie eine Eintrittspunkt-Skript `inference.py`-Datei angeben, die zum Zeitpunkt der Inferenz verwendet werden kann. Das Skript sollte entweder ein Paar von – `input_handler`und `output_handler`-Funktionen oder eine einzelne Handler-Funktion implementieren.
**Anmerkung**
Beachten Sie, dass wenn die Handler-Funktion implementiert ist, `input_handler` und `output_handler` ignoriert werden.
Im Folgenden finden Sie ein Codebeispiel für ein `inference.py` Skript, das Sie zusammen mit dem Kompilierungsmodell zusammenstellen können, um eine benutzerdefinierte Vor- und Nachbearbeitung eines Bildklassifizierungsmodells durchzuführen. Der SageMaker AI-Client sendet die Bilddatei als `application/x-image` Inhaltstyp an die `input_handler` Funktion, wo sie in JSON konvertiert wird. Die konvertierte Bilddatei wird dann mithilfe der REST-API an den [Tensorflow Model Server (TFX)](https://www.tensorflow.org/tfx/serving/api_rest) gesendet.
```
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
```
Wenn es keine benutzerdefinierte Vor- oder Nachverarbeitung gibt, konvertiert der SageMaker AI-Client das Dateibild auf ähnliche Weise in JSON, bevor er es an den SageMaker KI-Endpunkt sendet.
Weitere Informationen finden Sie unter [Deploying to TensorFlow Serving Endpoints im SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#providing-python-scripts-for-pre-pos-processing).
1. Die Amazon-S3-Bucket-URI, die die kompilierten Modellartefakte enthält.
# Stellen Sie ein kompiliertes Modell mithilfe des SDK SageMaker bereit
Sie müssen den Abschnitt mit den [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllen, wenn das Modell mit AWS SDK für Python (Boto3) AWS CLI, oder der Amazon SageMaker AI-Konsole kompiliert wurde. Folgen Sie einem der folgenden Anwendungsfälle, um ein mit SageMaker Neo kompiliertes Modell bereitzustellen, das auf der Art und Weise basiert, wie Sie Ihr Modell kompiliert haben.
**Topics**
+ [Wenn Sie Ihr Modell mit dem SageMaker SDK kompiliert haben](#neo-deployment-hosting-services-sdk-deploy-sm-sdk)
+ [Wenn Sie Ihr Modell mit MXNet oder kompiliert haben PyTorch](#neo-deployment-hosting-services-sdk-deploy-sm-boto3)
+ [Wenn Sie Ihr Modell mit Boto3, der SageMaker Konsole oder der CLI für kompiliert haben TensorFlow](#neo-deployment-hosting-services-sdk-deploy-sm-boto3-tensorflow)
## Wenn Sie Ihr Modell mit dem SageMaker SDK kompiliert haben
Das Objekthandle [sagemaker.Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model) für das kompilierte Modell liefert die Funktion [deploy()](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html?highlight=sagemaker.Model#sagemaker.model.Model.deploy), mit der Sie einen Endpunkt für Inferenzanforderungen erstellen können. Die Funktion ermöglicht es Ihnen, die Anzahl der Instances und Instance-Typen festzulegen, die für den Endpunkt verwendet werden. Sie müssen eine Instance wählen, für die Sie Ihr Modell kompiliert haben. In dem Job, der im Abschnitt [Compile a Model (Amazon SageMaker SDK) kompiliert](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-job-compilation-sagemaker-sdk.html) wurde, ist dies beispielsweise`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)
```
## Wenn Sie Ihr Modell mit MXNet oder kompiliert haben PyTorch
Erstellen Sie das SageMaker KI-Modell und stellen Sie es mithilfe der deploy () -API unter dem Framework-spezifischen Modell bereit. APIs Denn MXNet es ist [MXNetModel](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html?highlight=MXNetModel#mxnet-model) und für ist PyTorch es. [ PyTorchModel](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html?highlight=PyTorchModel#sagemaker.pytorch.model.PyTorchModel) Wenn Sie ein SageMaker KI-Modell erstellen und bereitstellen, müssen Sie die `MMS_DEFAULT_RESPONSE_TIMEOUT` Umgebungsvariable auf festlegen `500` und den `entry_point` Parameter als Inferenzskript (`inference.py`) und den `source_dir` Parameter als Verzeichnispfad (`code`) des Inferenzskripts angeben. Um das Inferenzskript (`inference.py`) vorzubereiten, folgen Sie dem Schritt Voraussetzungen.
Das folgende Beispiel zeigt, wie Sie diese Funktionen verwenden, um ein kompiliertes Modell mithilfe des SageMaker AI SDK für Python bereitzustellen:
------
#### [ 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)
```
------
**Anmerkung**
Die Richtlinien `AmazonSageMakerFullAccess` und `AmazonS3ReadOnlyAccess` müssen der `AmazonSageMaker-ExecutionRole` IAM-Rolle zugeordnet werden.
## Wenn Sie Ihr Modell mit Boto3, der SageMaker Konsole oder der CLI für kompiliert haben TensorFlow
Konstruieren Sie ein `TensorFlowModel` Objekt und rufen Sie anschließend deploy auf:
```
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)
```
Weitere Informationen finden Sie unter [Direktes Deployment aus Modellartefakten](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#deploying-directly-from-model-artifacts).
Sie können aus [dieser Liste](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) einen Amazon ECR-URI für ein Docker-Image auswählen, der Ihren Anforderungen entspricht.
[Weitere Informationen zum Konstruieren eines `TensorFlowModel` Objekts finden Sie im SageMaker SDK.](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-serving-model)
**Anmerkung**
Ihre erste Inferenzanforderung kann eine hohe Latenz haben, wenn Sie Ihr Modell auf einer GPU bereitstellen. Dies liegt daran, dass bei der ersten Inferenzanforderung ein optimierter Rechenkern erstellt wird. Wir empfehlen Ihnen, eine Aufwärmdatei mit Inferenzanfragen zu erstellen und diese zusammen mit Ihrer Modelldatei zu speichern, bevor Sie sie an ein TFX senden. Dies wird als „Aufwärmen“ des Modells bezeichnet.
Der folgende Codeausschnitt zeigt im Abschnitt mit den [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites), wie die Aufwärmdatei für die Bildklassifizierung erstellt wird:
```
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())
```
Weitere Informationen darüber, wie Sie Ihr Modell „aufwärmen“ können, finden Sie auf der [TensorFlow TFX-Seite](https://www.tensorflow.org/tfx/serving/saved_model_warmup).
# Stellen Sie ein kompiliertes Modell mit Boto3 bereit
Sie müssen den Abschnitt mit den [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllen, wenn das Modell mit AWS SDK für Python (Boto3) AWS CLI, oder der Amazon SageMaker AI-Konsole kompiliert wurde. Gehen Sie wie folgt vor, um ein SageMaker NEO-kompiliertes Modell mit dem [Amazon Web Services SDK for Python (Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)) zu erstellen und bereitzustellen.
**Topics**
+ [Stellen Sie das Modell bereit](#neo-deployment-hosting-services-boto3-steps)
## Stellen Sie das Modell bereit
Nachdem Sie die [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllt haben, verwenden Sie, `create_model` und`create_enpoint_config`. `create_endpoint` APIs
Das folgende Beispiel zeigt, wie Sie diese verwenden können APIs , um ein mit Neo kompiliertes Modell bereitzustellen:
```
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)
```
**Anmerkung**
Die Richtlinien `AmazonSageMakerFullAccess` und `AmazonS3ReadOnlyAccess` müssen der `AmazonSageMaker-ExecutionRole` IAM-Rolle zugeordnet werden.
Die vollständige Syntax von `create_model` `create_endpoint_config` `create_endpoint` APIs, und finden Sie unter [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), bzw..
Wenn Sie Ihr Modell nicht mit SageMaker KI trainiert haben, geben Sie die folgenden Umgebungsvariablen an:
------
#### [ 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"
}
```
------
Wenn Sie Ihr Modell mit SageMaker KI trainiert haben, geben Sie die Umgebungsvariable `SAGEMAKER_SUBMIT_DIRECTORY` als vollständigen Amazon S3 S3-Bucket-URI an, der das Trainingsskript enthält.
# Stellen Sie ein kompiliertes Modell mit dem bereit AWS CLI
Sie müssen den Abschnitt mit den [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllen, wenn das Modell mit AWS SDK für Python (Boto3) AWS CLI, oder der Amazon SageMaker AI-Konsole kompiliert wurde. Gehen Sie wie folgt vor, um ein SageMaker NEO-kompiliertes Modell mit dem [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)zu erstellen und bereitzustellen.
**Topics**
+ [Stellen Sie das Modell bereit](#neo-deploy-cli)
## Stellen Sie das Modell bereit
Wenn Sie die [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllt haben, verwenden Sie die `create-endpoint` AWS CLI Befehle `create-model``create-enpoint-config`, und. In den folgenden Schritten wird erläutert, wie Sie mit diesen Befehlen ein mit Neo kompiliertes Modell bereitstellen:
### Erstellen eines Modells
Wählen Sie [unter Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html) den URI für das Inferenzbild aus und verwenden Sie dann die `create-model` API, um ein SageMaker KI-Modell zu erstellen. Es gibt zwei Schritte dafür:
1. Erstellen Sie eine `create_model.json`-Datei. Geben Sie in der Datei den Namen des Modells, die Image-URI, den Pfad zur `model.tar.gz` Datei in Ihrem Amazon S3 S3-Bucket und Ihre SageMaker AI-Ausführungsrolle an:
```
{
"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"
}
```
Wenn Sie Ihr Modell mit SageMaker KI trainiert haben, geben Sie die folgende Umgebungsvariable an:
```
"Environment": {
"SAGEMAKER_SUBMIT_DIRECTORY" : "[Full S3 path for *.tar.gz file containing the training script]"
}
```
Wenn Sie Ihr Modell nicht mit SageMaker KI trainiert haben, geben Sie die folgenden Umgebungsvariablen an:
------
#### [ 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"
}
```
------
**Anmerkung**
Die Richtlinien `AmazonSageMakerFullAccess` und `AmazonS3ReadOnlyAccess` müssen der `AmazonSageMaker-ExecutionRole` IAM-Rolle zugeordnet werden.
1. Führen Sie den folgenden Befehl aus:
```
aws sagemaker create-model --cli-input-json file://create_model.json
```
Die vollständige Syntax der `create-model`-API finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html).
### Erstellen einer Endpunktkonfiguration
Nachdem Sie ein SageMaker KI-Modell erstellt haben, erstellen Sie die Endpunktkonfiguration mithilfe der `create-endpoint-config` API. Erstellen Sie dazu eine JSON-Datei mit Ihren Endpunktkonfigurationsspezifikationen. Sie können beispielsweise die folgende Codevorlage verwenden und sie als `create_config.json` speichern:
```
{
"EndpointConfigName": "",
"ProductionVariants": [
{
"VariantName": "",
"ModelName": "my-sagemaker-model",
"InitialInstanceCount": 1,
"InstanceType": "",
"InitialVariantWeight": 1.0
}
]
}
```
Führen Sie nun den folgenden AWS CLI Befehl aus, um Ihre Endpunktkonfiguration zu erstellen:
```
aws sagemaker create-endpoint-config --cli-input-json file://create_config.json
```
Die vollständige Syntax der `create-endpoint-config`-API finden Sie unter [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).
### Erstellen eines Endpunkts
Nachdem Sie Ihre Endpunktkonfiguration erstellt haben, erstellen Sie mithilfe der `create-endpoint` API einen Endpunkt:
```
aws sagemaker create-endpoint --endpoint-name '' --endpoint-config-name ''
```
Die vollständige Syntax der `create-endpoint`-API finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html).
# Stellen Sie ein kompiliertes Modell mithilfe der Konsole bereit
Sie müssen den Abschnitt mit den [Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllen AWS SDK für Python (Boto3), wenn das Modell mit der oder der AWS CLI Amazon SageMaker AI-Konsole kompiliert wurde. Gehen Sie wie folgt vor, um ein mit SageMaker KI NEO kompiliertes Modell mithilfe der AI-Konsole SageMaker [https://console.aws.amazon.com SageMaker /AI](https://console.aws.amazon.com/sagemaker/) zu erstellen und bereitzustellen.
**Topics**
+ [Stellen Sie das Modell bereit](#deploy-the-model-console-steps)
## Stellen Sie das Modell bereit
Nachdem Sie die [ Voraussetzungen](https://docs.aws.amazon.com//sagemaker/latest/dg/neo-deployment-hosting-services-prerequisites) erfüllt haben, führen Sie die folgenden Schritte aus, um ein mit Neo kompiliertes Modell bereitzustellen:
1. Wählen Sie **Models (Modelle)** und dann **Create models (Modelle erstellen)** in der Gruppe **Inference (Inferenz)** aus. Füllen Sie auf der Seite **Modell erstellen** die Felder **Modellname**, **IAM-Rolle** und **VPC** (optional) aus, falls erforderlich.
![\[Erstellen eines Neo-Modells für Inferenz\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/create-pipeline-model.png)
1. Zum Hinzufügen von Informationen über den für die Bereitstellung Ihres Modells verwendeten Container wählen Sie **Container hinzufügen** und dann **Weiter** aus. Machen Sie die nötigen Angaben unter **Containereingabeoptionen**, **Speicherort des Inferenzcodeabbilds** und **Speicherort der Modellartefakte** und optional auch unter **Containerhostname** und **Umgebungsvariablen**.
![\[Erstellen eines Neo-Modells für Inferenz\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/neo-deploy-console-container-definition.png)
1. Zum Bereitstellen von mit Neo kompilierten Modellen wählen Sie die folgenden Optionen:
+ **Containereingabeoptionen**: Wählen Sie **Modellartefakte und Inferenz-Images bereitstellen**.
+ **Speicherort des Inferenzcode-Bildes**: Wählen Sie den URI des Inferenz-Image aus [Neo Inference Container Images](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-deployment-hosting-services-container-images.html), abhängig von der AWS -Region und der Art der Anwendung.
+ **Speicherort des Modell-Artefakts**: Geben Sie den Amazon-S3-Bucket-URI des kompilierten Modell-Artefakts ein, das von der Neo Compilation API erzeugt wurde.
+ **Umgebungsvariablen**:
+ Lassen Sie dieses Feld leer für **SageMaker XGBoost**.
+ Wenn Sie Ihr Modell mit SageMaker KI trainiert haben, geben Sie die Umgebungsvariable `SAGEMAKER_SUBMIT_DIRECTORY` als Amazon S3 S3-Bucket-URI an, die das Trainingsskript enthält.
+ Wenn Sie Ihr Modell nicht mit SageMaker KI trainiert haben, geben Sie die folgenden Umgebungsvariablen an:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/neo-deployment-hosting-services-console.html)
1. Vergewissern Sie sich, dass die Informationen zu den Containern richtig sind, und klicken Sie dann auf **Create Model (Modell erstellen)**. Wählen Sie auf der **Modell Landingpage erstellen** die Option **Endpunkt erstellen** aus.
![\[Modell Landingpage erstellen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/neo-deploy-console-create-model-land-page.png)
1. Geben Sie im Bereich **Endpunkt erstellen und konfigurieren** unter **Endpunktname** den Namen des Endpunkts an. Wählen Sie für **Endpunktkonfiguration anhängen** die Option **Neue Endpunktkonfiguration erstellen** aus.
![\[Benutzeroberfläche zum Erstellen und Konfigurieren eines Endpunkts in der Neo-Konsole\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/neo-deploy-console-config-endpoint.png)
1. Geben Sie auf der Seite **Neue Endpunktkonfiguration** unter **Endpunktkonfigurationsname** den Namen der Endpunktkonfiguration an.
![\[Benutzeroberfläche zum Erstellen einer neuen Endpunktkonfiguration in der Neo-Konsole\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/neo-deploy-console-new-endpoint-config.png)
1. Wählen Sie neben dem Namen des Modells die Option **Bearbeiten** aus und geben Sie auf der Seite **Produktionsvariante bearbeiten** den richtigen **Instance-Typ** an. Der Wert unter **Instance-Typ** muss unbedingt mit dem in Ihrem Kompilierungsauftrag angegebenen Instance-Typ übereinstimmen.
![\[Benutzeroberfläche zum Erstellen einer neuen Endpunktkonfiguration in der Neo-Konsole\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/neo-deploy-console-edit-production-variant.png)
1. Wählen Sie **Speichern**.
1. Wählen Sie auf der Seite **Neue Endpunktkonfiguration** die Option **Endpunktkonfiguration erstellen** und dann **Endpunkt erstellen** aus.
# Inferenzanfragen mit einem bereitgestellten Dienst
Wenn Sie die Anweisungen unter befolgt haben[Bereitstellen eines Modells](neo-deployment-hosting-services.md), sollten Sie einen SageMaker KI-Endpunkt eingerichtet und in Betrieb haben. Unabhängig davon, wie Sie Ihr NEO-kompiliertes Modell bereitgestellt haben, gibt es drei Möglichkeiten, Inferenzanfragen einzureichen:
**Topics**
+ [Inferenzen von einem bereitgestellten Service anfordern (Amazon SageMaker SDK)](neo-requests-sdk.md)
+ [Anfordern von Inferenzen von einem bereitgestellten Service (Boto3)](neo-requests-boto3.md)
+ [Inferenzen von einem bereitgestellten Dienst (AWS CLI) anfordern](neo-requests-cli.md)
# Inferenzen von einem bereitgestellten Service anfordern (Amazon SageMaker SDK)
Verwenden Sie die folgenden Codebeispiele, um Rückschlüsse von Ihrem bereitgestellten Dienst anzufordern, die auf dem Framework basieren, das Sie zum Trainieren Ihres Modells verwendet haben. Die Codebeispiele für die verschiedenen Frameworks sind ähnlich. Der Hauptunterschied besteht darin, dass der Inhaltstyp TensorFlow erfordert`application/json`.
## PyTorch und MXNet
Wenn Sie **PyTorch v1.4 oder höher oder **MXNet 1.7.0 oder höher**** verwenden und über einen Amazon SageMaker AI-Endpunkt verfügen`InService`, können Sie mit dem `predictor` Paket des SageMaker AI SDK für Python Inferenzanfragen stellen.
**Anmerkung**
Die API variiert je nach Version des SageMaker AI SDK für Python:
Verwenden Sie für Version 1.x die [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) und [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) API.
Verwenden Sie für Version 2.x die [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)und [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) API.
Das folgende Codebeispiel zeigt, wie diese verwendet werden APIs , um ein Bild zur Inferenz zu senden:
------
#### [ 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
Das folgende Codebeispiel zeigt, wie die SageMaker Python SDK-API verwendet wird, um ein Bild zur Inferenz zu senden:
```
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)
```
# Anfordern von Inferenzen von einem bereitgestellten Service (Boto3)
Sie können Inferenzanfragen mit dem SageMaker AI SDK for Python (Boto3) -Client und der [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)API einreichen, sobald Sie über einen SageMaker KI-Endpunkt verfügen. `InService` Das folgende Codebeispiel zeigt, wie ein Bild zur Inferenz gesendet wird.
------
#### [ 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 ]
Zum TensorFlow Einreichen einer Eingabe mit `application/json` für den Inhaltstyp.
```
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 ]
Für eine XGBoost Bewerbung sollten Sie stattdessen einen CSV-Text einreichen:
```
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())
```
------
Beachten Sie, dass BYOM einen benutzerdefinierten Inhaltstyp erlaubt. Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html).
# Inferenzen von einem bereitgestellten Dienst (AWS CLI) anfordern
Inferenzanfragen können mit dem gestellt werden, [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)sobald Sie einen Amazon SageMaker AI-Endpunkt `InService` haben. Sie können Inferenzanfragen mit dem AWS Command Line Interface (AWS CLI) stellen. Das folgende Beispiel zeigt, wie ein Bild zur Inferenz gesendet wird.
```
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
```
Eine `output_file.txt` mit Informationen zu Ihren Inferenzanfragen wird gestellt, wenn die Inferenz erfolgreich war.
Um eine Eingabe mit `application/json` als Inhaltstyp TensorFlow einzureichen.
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'insert name of your endpoint here' --body fileb://input.json --content-type=application/json output_file.txt
```
# Inferenzcontainer-Bilder
SageMaker Neo stellt jetzt URI-Informationen zu Inferenzbildern für `ml_*` Ziele bereit. Weitere Informationen finden Sie unter [DescribeCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeCompilationJob.html#sagemaker-DescribeCompilationJob-response-InferenceImage).
Ersetzen Sie je nach Anwendungsfall den hervorgehobenen Teil in der unten angegebenen URI-Vorlage für das Inferenz-Image durch die entsprechenden Werte.
## Amazon SageMaker KI XGBoost
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/xgboost-neo:latest
```
Ersetzen Sie *aws\$1account\$1id* aus der Tabelle am Ende dieser Seite, basierend auf dem, was *aws\$1region* Sie verwendet haben.
## Keras
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-keras:fx_version-instance_type-py3
```
Ersetzen Sie *aws\$1account\$1id* aus der Tabelle am Ende dieser Seite, basierend auf dem, was *aws\$1region* Sie verwendet haben.
Ersetzen Sie *fx\$1version* durch `2.2.4`.
*instance\$1type*Ersetzen Sie durch entweder `cpu` oder`gpu`.
## MXNet
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-mxnet:fx_version-instance_type-py3
```
Ersetzen Sie anhand der *aws\$1account\$1id* von *aws\$1region* Ihnen verwendeten Werte aus der Tabelle am Ende dieser Seite.
Ersetzen Sie *fx\$1version* durch `1.8.0`.
*instance\$1type*Ersetzen Sie durch entweder `cpu` oder`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-mxnet:fx_version-instance_type-py3
```
*aws\$1region*Durch entweder `us-east-1` oder ersetzen`us-west-2`.
Ersetzen Sie anhand der *aws\$1account\$1id* von *aws\$1region* Ihnen verwendeten Werte aus der Tabelle am Ende dieser Seite.
Ersetzen Sie *fx\$1version* durch `1.5.1`.
Ersetzen Sie *`instance_type`* durch `inf`.
------
## ONNX
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-onnx:fx_version-instance_type-py3
```
Ersetzen Sie *aws\$1account\$1id* aus der Tabelle am Ende dieser Seite, basierend auf dem, was *aws\$1region* Sie verwendet haben.
Ersetzen Sie *fx\$1version* durch `1.5.0`.
*instance\$1type*Ersetzen Sie durch entweder `cpu` oder`gpu`.
## PyTorch
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-pytorch:fx_version-instance_type-py3
```
Ersetzen Sie anhand der *aws\$1account\$1id* von *aws\$1region* Ihnen verwendeten Werte aus der Tabelle am Ende dieser Seite.
*fx\$1version*Ersetzen Sie durch `1.4``1.5`,`1.6`,`1.7`,`1.8`,`1.12`,`1.13`, oder`2.0`.
*instance\$1type*Durch entweder `cpu` oder ersetzen`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-pytorch:fx_version-instance_type-py3
```
*aws\$1region*Durch entweder `us-east-1` oder ersetzen`us-west-2`.
Ersetzen Sie anhand der *aws\$1account\$1id* von *aws\$1region* Ihnen verwendeten Werte aus der Tabelle am Ende dieser Seite.
Ersetzen Sie *fx\$1version* durch `1.5.1`.
Ersetzen Sie *`instance_type`* durch `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*Ersetzen Sie durch `us-east-2` für Inferentia2 und `us-east-1` für Trainium1.
------
## TensorFlow
------
#### [ CPU or GPU instance types ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-inference-tensorflow:fx_version-instance_type-py3
```
Ersetzen Sie *aws\$1account\$1id* aus der Tabelle am Ende dieser Seite, basierend auf dem, was Sie verwendet haben. *aws\$1region*
Ersetzen Sie *fx\$1version* durch `1.15.3` oder `2.9`.
*instance\$1type*Ersetzen Sie durch entweder `cpu` oder`gpu`.
------
#### [ Inferentia1 ]
```
aws_account_id.dkr.ecr.aws_region.amazonaws.com/sagemaker-neo-tensorflow:fx_version-instance_type-py3
```
Ersetzen Sie anhand der *aws\$1account\$1id* von *aws\$1region* Ihnen verwendeten Werte aus der Tabelle am Ende dieser Seite. Beachten Sie, dass zum Beispiel nur Instance-Type `inf` nur `us-east-1` und `us-west-2` unterstützt.
Ersetze *fx\$1version* durch `1.15.0`
Ersetzen Sie *instance\$1type* durch `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*Ersetzen Sie durch `us-east-2` für Inferentia2 und `us-east-1` für Trainium1.
------
Die folgende Tabelle entspricht. *aws\$1account\$1id* *aws\$1region* Verwenden Sie diese Tabelle, um den richtigen Inferenz-Image-URI zu finden, den Sie für Ihre Anwendung benötigen.
| aws\$1account\$1id | aws\$1region |
| --- | --- |
| 785573368785 | us-east-1 |
| 007439368137 | 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 |