Voraussetzungen - Amazon SageMaker

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 for Python (Boto3), AWS CLI oder der Konsole kompiliert haben. SageMaker

Um ein SageMaker NEO-kompiliertes Modell zu erstellen, benötigen Sie Folgendes:

  1. Ein Docker-Image von Amazon ECRURI. 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 trainiert haben SageMaker, muss das Trainingsskript die unten beschriebenen Funktionen implementieren. Das Trainingsskript dient als Einstiegsskript für Inferenzen. In dem unter MNISTTraining, 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 trainiert haben SageMaker, müssen Sie eine Einstiegspunktskriptdatei (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 SDK Python-Modellverzeichnisstruktur für MxNet oder der Modellverzeichnisstruktur für entsprechen. PyTorch

      Bei der Verwendung von für Neo Inference optimierten Container-Images mit PyTorchCPUund MXNetauf 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 einem 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 Client sendet die Bilddatei als application/x-image Inhaltstyp an die input_handler Funktion, in die sie konvertiert wirdJSON. Die konvertierte Bilddatei wird dann mit dem an den Tensorflow Model Server (TFX) gesendet. 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

      Wenn es keine benutzerdefinierte Vor- oder Nachbearbeitung gibt, konvertiert der SageMaker Client das Dateibild auf JSON ähnliche Weise, bevor er es an den Endpunkt sendet. SageMaker

      Weitere Informationen finden Sie unter Deploying to TensorFlow Serving Endpoints in SageMaker Python SDK.

  3. Der Amazon S3 S3-BucketURI, der die kompilierten Modellartefakte enthält.