Pré-requisitos

nota

Siga as instruções nesta seção se você compilou seu modelo usando AWS SDK for Python (Boto3) AWS CLI, ou o SageMaker console.

Para criar um modelo SageMaker neocompilado, você precisa do seguinte:

1. Uma imagem Docker da Amazon ECRURI. Você pode selecionar um que atenda às suas necessidades nesta lista.

2. Um arquivo de script de ponto de entrada:

   1. Para PyTorch e MXNet modelos:

      Se você treinou seu modelo usando SageMaker, o script de treinamento deve implementar as funções descritas abaixo. O script de treinamento serve como o script de ponto de entrada durante a inferência. No exemplo detalhado em MNISTTreinamento, compilação e implantação com MXNet módulo e SageMaker Neo, o script de treinamento (mnist.py) implementa as funções necessárias.

      Se você não treinou seu modelo usando SageMaker, precisará fornecer um arquivo script (inference.py) de ponto de entrada que possa ser usado no momento da inferência. Com base na estrutura — MXNet ou PyTorch — a localização do script de inferência deve estar em conformidade com a Estrutura de Diretórios do SDK Modelo SageMaker Python para MxNet ou a Estrutura de Diretórios do Modelo para. PyTorch

      Ao usar imagens do Neo Inference Optimized Container com PyTorche MXNeton CPU e tipos de GPU instância, o script de inferência deve implementar as seguintes funções:

      • model_fn: carrega o modelo. (Optional)

      • input_fn: converte a carga útil da solicitação recebida em uma matriz numérica.

      • predict_fn: executa a previsão.

      • output_fn: converte a saída de previsão na carga útil de resposta.

      • Como alternativa, você pode definir transform_fn para combinar input_fn, predict_fn e output_fn.

      Veja a seguir exemplos de inference.py script em um diretório chamado code (code/inference.py) for PyTorch and MXNet (Gluon and Module). Os exemplos primeiro carregam o modelo e depois o servem em dados de imagem em umGPU:

      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. Para instâncias inf1 ou imagens de contêiner onnx, xgboost e keras

      Para todas as outras imagens de contêiner otimizadas pelo Neo Inference ou tipos de instância de inferência, o script de ponto de entrada deve implementar as seguintes funções para o Neo Deep Learning Runtime:

      • neo_preprocess: converte a carga útil da solicitação recebida em uma matriz numérica.

      • neo_postprocess: converte a saída de previsão do Neo Deep Learning Runtime no corpo da resposta.

        nota

        As duas funções anteriores não usam nenhuma das funcionalidades deMXNet, PyTorch, ou. TensorFlow

      Para obter exemplos de como usar essas funções, consulte Blocos de anotações de amostra de compilação de modelos Neo.

   3. Para TensorFlow modelos

      Se seu modelo exigir uma lógica personalizada de pré e pós-processamento antes que os dados sejam enviados ao modelo, você deverá especificar um arquivo de script inference.py de ponto de entrada que possa ser usado no momento da inferência. O script deve implementar um par de funções input_handler eoutput_handler ou uma única função de manipulador.

      nota

      Observe que, se a função do manipulador for implementada, input_handler e output_handler são ignoradas.

      Veja a seguir um exemplo de código de script inference.py que você pode montar com o modelo de compilação para realizar o pré-processamento e o pós-processamento personalizados em um modelo de classificação de imagens. O SageMaker cliente envia o arquivo de imagem como um tipo de application/x-image conteúdo para a input_handler função, na qual ele é convertidoJSON. O arquivo de imagem convertido é então enviado para o Tensorflow Model Server (TFX) usando o. 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

      Se não houver pré-processamento ou pós-processamento personalizado, o SageMaker cliente converte a imagem do arquivo JSON em uma forma semelhante antes de enviá-la para o SageMaker endpoint.

      Para obter mais informações, consulte Implantação para TensorFlow servir endpoints no Python SageMaker . SDK

3. O bucket do Amazon S3 URI que contém os artefatos do modelo compilado.