Erstellen Sie Amazon SageMaker-Modelle mit dem PyTorch Model Zoo

Die Bereitstellung hochwertiger, trainierter Modelle für maschinelles Lernen (ML), um entweder Batch- oder Echtzeit-Inferenzen durchzuführen, ist ein entscheidender Faktor, um Kunden einen Mehrwert zu bieten. Der ML-Experimentierprozess kann jedoch langwierig sein – es gibt viele Ansätze, deren Implementierung viel Zeit in Anspruch nimmt. Aus diesem Grund sind vortrainierte ML-Modelle wie die in der bereitgestellten PyTorch-Modellzoo sind so hilfreich. Amazon Sage Maker bietet eine einheitliche Schnittstelle zum Experimentieren mit verschiedenen ML-Modellen, und der PyTorch Model Zoo ermöglicht es uns, unsere Modelle auf standardisierte Weise einfach auszutauschen.

Dieser Blogbeitrag zeigt, wie Sie ML-Inferenz mithilfe eines Objekterkennungsmodells aus dem PyTorch-Modellzoo in SageMaker durchführen. Vortrainierte ML-Modelle aus dem PyTorch Model Zoo sind vorgefertigt und können problemlos als Teil von ML-Anwendungen verwendet werden. Einrichten dieser ML-Modelle als SageMaker-Endpunkt oder SageMaker-Batch-Transformation Job für Online- oder Offline-Inferenz ist mit den in diesem Blogbeitrag beschriebenen Schritten einfach. Wir verwenden a Schnelleres R-CNN Objekterkennungsmodell zur Vorhersage von Begrenzungsrahmen für vordefinierte Objektklassen.

Wir gehen ein End-to-End-Beispiel durch, vom Laden der Faster R-CNN-Objekterkennungsmodellgewichtungen bis zum Speichern in einer Einfacher Amazon-Speicherdienst (Amazon S3) Bucket und das Schreiben einer Einstiegspunktdatei und das Verständnis der Schlüsselparameter in der PyTorchModel-API. Schließlich werden wir das ML-Modell bereitstellen, mit SageMaker Batch Transform Rückschlüsse darauf ziehen, die ML-Modellausgabe untersuchen und lernen, wie die Ergebnisse zu interpretieren sind. Diese Lösung kann auf jedes andere vortrainierte Modell im PyTorch Model Zoo angewendet werden. Eine Liste der verfügbaren Modelle finden Sie unter PyTorch Model Zoo-Dokumentation.

Lösungsüberblick

Dieser Blogbeitrag führt Sie durch die folgenden Schritte. Eine voll funktionsfähige Version aller Schritte finden Sie unter create_pytorch_model_sagemaker.ipynb

• Schritt 1: Einrichtung
• Schritt 2: Laden eines ML-Modells aus dem PyTorch Model Zoo
• Schritt 3 Speichern Sie ML-Modellartefakte und laden Sie sie in Amazon S3 hoch
• Schritt 4: Erstellen von ML-Modell-Inferenzskripten
• Schritt 5: Starten eines SageMaker-Batch-Transformationsjobs
• Schritt 6: Visualisierung der Ergebnisse

Architekturdiagramm

Verzeichnisstruktur

Den Code für diesen Blog finden Sie hier GitHub-Repository. Die Codebasis enthält alles, was wir zum Erstellen von ML-Modellartefakten, zum Starten des Transformationsjobs und zum Visualisieren der Ergebnisse benötigen.

Dies ist der Workflow, den wir verwenden. Alle folgenden Schritte beziehen sich auf Module in dieser Struktur.

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

Das sagemaker_torch_model_zoo Ordner sollte enthalten inference.py als Einstiegspunktdatei und create_pytorch_model_sagemaker.ipynb zum Laden und Speichern der Modellgewichte, zum Erstellen eines SageMaker-Modellobjekts und zum Übergeben dieses schließlich an einen SageMaker-Batch-Transformationsauftrag. Um Ihre eigenen ML-Modelle mitzubringen, ändern Sie die Pfade im Abschnitt Schritt 1: Setup des Notebooks und laden Sie ein neues Modell im Abschnitt Schritt 2: Laden eines ML-Modells aus dem Abschnitt PyTorch Model Zoo. Der Rest der folgenden Schritte würde gleich bleiben.

Schritt 1: Einrichtung

IAM-Rollen

SageMaker führt Operationen auf der Infrastruktur durch, die von SageMaker verwaltet wird. SageMaker kann nur zulässige Aktionen ausführen, die in der begleitenden IAM-Ausführungsrolle des Notebooks für SageMaker definiert sind. Eine ausführlichere Dokumentation zum Erstellen von IAM-Rollen und zum Verwalten von IAM-Berechtigungen finden Sie unter Dokumentation zu AWS SageMaker-Rollen. Wir können eine neue Rolle erstellen oder die bekommen SageMaker (Studio)-Notizbuchdie standardmäßige Ausführungsrolle von , indem Sie die folgenden Codezeilen ausführen:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

Der obige Code ruft die SageMaker-Ausführungsrolle für die Notebook-Instance ab. Dies ist die IAM-Rolle, die wir für unsere SageMaker- oder SageMaker Studio-Notebook-Instance erstellt haben.

Benutzerkonfigurierbare Parameter

Hier sind alle konfigurierbaren Parameter, die zum Erstellen und Starten unseres SageMaker-Batch-Transformationsjobs erforderlich sind:

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

Schritt 2: Laden eines ML-Modells aus dem PyTorch Model Zoo

Als Nächstes spezifizieren wir ein Objekterkennungsmodell aus dem PyTorch Model Zoo und speichern seine ML-Modellgewichtungen. Normalerweise speichern wir ein PyTorch-Modell mit den Dateierweiterungen .pt oder .pth. Das folgende Code-Snippet lädt ein vortrainiertes Faster R-CNN ResNet50 ML-Modell aus dem PyTorch Model Zoo herunter:

model = Torchvision.models.detection.fasterrcnn_resnet50_fpn(vortrainiert=True)

Die SageMaker-Stapeltransformation erfordert als Eingabe einige Modellgewichtungen, daher speichern wir das vorab trainierte ML-Modell als model.pt. Wenn wir ein benutzerdefiniertes Modell laden möchten, könnten wir stattdessen die Modellgewichte eines anderen PyTorch-Modells als model.pt speichern.

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

Schritt 3: Speichern Sie ML-Modellartefakte und laden Sie sie in Amazon S3 hoch

Da wir SageMaker für ML-Inferenz verwenden werden, müssen wir die Modellgewichtungen in einen S3-Bucket hochladen. Wir können dies mit den folgenden Befehlen oder durch Herunterladen und einfaches Ziehen und Ablegen der Datei direkt in S3 tun. Die folgenden Befehle komprimieren zuerst die Gruppe von Dateien darin model.pt in einen Tarball und kopieren Sie die Modellgewichte von unserer lokalen Maschine in den S3-Bucket.

Note: Um die folgenden Befehle auszuführen, benötigen Sie die AWS-Befehlszeilenschnittstelle (AWS CLI) installiert.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

Als nächstes kopieren wir unser Eingabebild nach S3. Unten ist der vollständige S3-Pfad für das Bild.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

Wir können dieses Image mit einem anderen aws s3 cp-Befehl auf S3 kopieren.

aws s3 cp cars.jpg $car_image_path

Schritt 4: Erstellen von ML-Modell-Inferenzskripten

Jetzt gehen wir unsere Entrypoint-Datei durch, inference.py Modul. Wir können ein außerhalb von SageMaker trainiertes PyTorch-Modell mithilfe der PyTorchModel-Klasse bereitstellen. Zuerst instanziieren wir das PyTorchModelZoo-Objekt. Dann erstellen wir eine inference.py-Einstiegspunktdatei, um ML-Inferenz mit SageMaker-Batch-Transformation für in Amazon S3 gehostete Beispieldaten durchzuführen.

Verstehen des PyTorchModel-Objekts

Das PyTorchModell -Klasse innerhalb der SageMaker-Python-API ermöglicht es uns, ML-Inferenzen mithilfe unseres heruntergeladenen Modellartefakts durchzuführen.

Um die PyTorchModel-Klasse zu initiieren, müssen wir die folgenden Eingabeparameter verstehen:

• name: Modellname; Wir empfehlen, entweder den Modellnamen + Datumszeit oder eine zufällige Zeichenfolge + Datumszeit für die Eindeutigkeit zu verwenden.
• model_data: Der S3-URI des gepackten ML-Modellartefakts.
• entry_point: Eine benutzerdefinierte Python-Datei, die vom Inferenz-Docker-Image verwendet wird, um Handler für eingehende Anforderungen zu definieren. Der Code definiert das Laden des Modells, die Eingabevorverarbeitung, die Vorhersagelogik und die Ausgabenachverarbeitung.
• framework_version: Muss auf Version 1.2 oder höher eingestellt werden, um die automatische Neupaketierung von PyTorch-Modellen zu aktivieren.
• source_dir: Das Verzeichnis der entry_point-Datei.
• role: Eine IAM-Rolle, um AWS-Serviceanfragen zu stellen.
• image_uri: Verwenden Sie dieses Amazon ECR-Docker-Container-Image als Basis für die Rechenumgebung des ML-Modells.
• sagemaker_session: Die SageMaker-Sitzung.
• py_version: Die zu verwendende Python-Version

Das folgende Code-Snippet instanziiert die PyTorchModel-Klasse, um eine Inferenz mit dem vorab trainierten PyTorch-Modell durchzuführen:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

Grundlegendes zur Entrypoint-Datei (inference.py)

Der Parameter entry_point verweist auf eine Python-Datei mit dem Namen inference.py. Dieser Einstiegspunkt definiert das Laden des Modells, die Eingabevorverarbeitung, die Vorhersagelogik und die Ausgabenachverarbeitung. Es ergänzt den Bereitstellungscode für das ML-Modell im vorgefertigten PyTorch SageMaker Deep Learning-Container Bild.

Inference.py enthält die folgenden Funktionen. In unserem Beispiel implementieren wir die model_fn, input_fn, predict_fn und output_fn Funktionen zum Überschreiben der standardmäßiger PyTorch-Inferenz-Handler.

1. model_fn: Nimmt ein Verzeichnis auf, das statische Modellprüfpunkte im Inferenzbild enthält. Öffnet und lädt das Modell aus einem angegebenen Pfad und gibt ein PyTorch-Modell zurück.
2. input_fn: Nimmt die Nutzdaten der eingehenden Anfrage (request_body) und den Inhaltstyp einer eingehenden Anfrage (request_content_type) als Eingabe auf. Behandelt die Datendekodierung. Diese Funktion muss an die vom Modell erwartete Eingabe angepasst werden.
3. predict_fn: Ruft ein Modell für in input_fn deserialisierte Daten auf. Führt eine Vorhersage für das deserialisierte Objekt mit dem geladenen ML-Modell durch.
4. output_fn: Serialisiert das Vorhersageergebnis in den gewünschten Antwortinhaltstyp. Konvertiert Vorhersagen, die von der Vorhersage_fn-Funktion erhalten wurden, in JSON-, CSV- oder NPY-Formate.

Schritt 5: Starten eines SageMaker-Batch-Transformationsjobs

In diesem Beispiel erhalten wir ML-Inferenzergebnisse über einen SageMaker-Stapeltransformationsauftrag. Batch-Transformationsjobs sind am nützlichsten, wenn wir einmal Rückschlüsse aus Datensätzen erhalten möchten, ohne dass ein dauerhafter Endpunkt erforderlich ist. Wir instanziieren a sagemaker.transformer.Transformator -Objekt zum Erstellen von und Interagieren mit SageMaker-Stapeltransformationsaufträgen.

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

Weitere Informationen finden Sie in der Dokumentation zum Erstellen eines Stapeltransformationsauftrags unter CreateTransformJob.

Schritt 6: Ergebnisse visualisieren

Sobald der SageMaker-Batch-Transformationsjob abgeschlossen ist, können wir die ML-Inferenzausgaben von Amazon S3 laden. Navigieren Sie dazu zu AWS-Managementkonsole und suchen Sie nach Amazon SageMaker. Auf der linken Seite, darunter Inferenz, Siehe Batch-Transformationsjobs.

Nach der Auswahl Batch-Transformationfinden Sie auf der Webseite, die alle SageMaker-Batch-Transformationsjobs auflistet. Wir können den Fortschritt unserer letzten Auftragsausführung anzeigen.

Zunächst hat der Job den Status „InProgress“. Sobald dies erledigt ist, sehen Sie, wie sich der Status in Abgeschlossen ändert.

Sobald der Status als abgeschlossen markiert ist, können wir auf den Job klicken, um die Ergebnisse anzuzeigen. Diese Webseite enthält die Jobzusammenfassung, einschließlich der Konfigurationen des Jobs, den wir gerade ausgeführt haben.

Der Ausgangsdatenkonfiguration, sehen wir einen S3-Ausgangspfad. Hier finden wir unsere ML-Inferenzausgabe.

Wählen Sie den S3-Ausgabepfad und sehen Sie sich eine [image_name].[file_type].out-Datei mit unseren Ausgabedaten an. Unsere Ausgabedatei enthält eine Liste von Zuordnungen. Beispielausgabe:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

Um diese Vorhersagen zu visualisieren, lesen wir zuerst den Ausgangspfad von unserem Transformatorobjekt.

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

Als nächstes verarbeiten wir diese Ausgabedatei und visualisieren unsere Vorhersagen. Nachfolgend geben wir unsere Vertrauensschwelle an. Wir erhalten die Liste der Klassen von der COCO-Dataset-Objektzuordnung. Während der Inferenz benötigt das Modell nur die Eingabetensoren und gibt die nachbearbeiteten Vorhersagen als List[Dict[Tensor]] zurück, eine für jedes Eingabebild. Die Felder des Diktats sind wie folgt, wobei N die Anzahl der Erkennungen ist:

1. Boxen (FloatTensor[N, 4]): die vorhergesagten Boxen in [x1, y1, x2, y2] Format, mit 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Wobei W ist die Breite des Bildes und H ist die Höhe des Bildes
2. Etiketten (Int64Tensor[N]): die vorhergesagten Labels für jede Erkennung
3. Partituren (Tensor[N]): die Vorhersagewerte für jede Erkennung

Weitere Einzelheiten zur Ausgabe finden Sie unter PyTorch Faster R-CNN FPN-Dokumentation.

Die Modellausgabe enthält Begrenzungsrahmen mit entsprechenden Konfidenzwerten. Wir können die Anzeige falsch positiver Ergebnisse optimieren, indem wir Begrenzungsrahmen entfernen, für die das Modell nicht sicher ist. Die folgenden Codeausschnitte verarbeiten die Vorhersagen in der Ausgabedatei und zeichnen Begrenzungsrahmen um die Vorhersagen, wenn die Punktzahl über unserem Konfidenzschwellenwert liegt. Wir legen die Wahrscheinlichkeitsschwelle fest, CONF_THRESH, bis 75 für dieses Beispiel.

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

Schließlich visualisieren wir diese Zuordnungen, um unsere Ausgabe zu verstehen.

Note: Wenn das Bild nicht in Ihrem Notebook angezeigt wird, suchen Sie es bitte im Verzeichnisbaum auf der linken Seite von JupyterLab und öffnen Sie es von dort aus.

Ausführen des Beispielcodes

Klonen Sie für ein voll funktionsfähiges Beispiel den Code in der amazon-sagemaker-beispiele GitHub und führen Sie die Zellen in der create_pytorch_model_sagemaker.ipynb Notebook.

Zusammenfassung

In diesem Blogbeitrag haben wir ein End-to-End-Beispiel für die Durchführung von ML-Inferenzen mit einem Objekterkennungsmodell aus dem PyTorch Model Zoo unter Verwendung der SageMaker-Batch-Transformation vorgestellt. Wir haben das Laden der Objekterkennungsmodellgewichte von Faster R-CNN, das Speichern in einem S3-Bucket, das Schreiben einer Einstiegspunktdatei und das Verständnis der Schlüsselparameter in der PyTorchModel-API behandelt. Schließlich haben wir das Modell bereitgestellt und eine ML-Modellinferenz durchgeführt, die Modellausgabe visualisiert und gelernt, wie die Ergebnisse zu interpretieren sind.

Über die Autoren

Dipika Khullar ist ein ML-Ingenieur in der Amazon ML-Lösungslabor. Sie hilft Kunden bei der Integration von ML-Lösungen zur Lösung ihrer Geschäftsprobleme. Zuletzt hat sie Trainings- und Inferenz-Pipelines für Medienkunden und Vorhersagemodelle für das Marketing entwickelt.

Marcelo Aberle ist ein ML-Ingenieur in der AWS-KI-Organisation. Er leitet die MLOps-Bemühungen bei der Amazon ML-Lösungslabor, unterstützt Kunden bei der Entwicklung und Implementierung skalierbarer ML-Systeme. Seine Mission ist es, Kunden auf ihrer Enterprise-ML-Reise zu begleiten und ihren ML-Weg zur Produktion zu beschleunigen.

Ninad Kulkarni ist Angewandte Wissenschaftlerin in der Amazon ML-Lösungslabor. Er hilft Kunden bei der Einführung von ML und KI, indem er Lösungen zur Bewältigung ihrer Geschäftsprobleme entwickelt. Zuletzt hat er Vorhersagemodelle für Sport-, Automobil- und Medienkunden entwickelt.

Jasch Schah ist Wissenschaftsmanagerin in der Amazon ML-Lösungslabor. Er und sein Team aus angewandten Wissenschaftlern und ML-Ingenieuren arbeiten an einer Reihe von ML-Anwendungsfällen aus den Bereichen Gesundheitswesen, Sport, Automobil und Fertigung.