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. # 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.