Voraussetzungen

Anmerkung

Folgen Sie den Anweisungen in diesem Abschnitt, wenn Sie Ihr Modell mit AWS SDK for 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 eine auswählen, die Ihren Anforderungen entspricht.

2. 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 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 for entsprechen. PyTorch

      Bei der Verwendung von Neo Inference Optimized Container-Images mit PyTorchund MXNetauf 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                                                
                                                  

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

   3. 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_handlerund 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) 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.

3. Die Amazon-S3-Bucket-URI, die die kompilierten Modellartefakte enthält.