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.

Erstellen Sie ein Modell in Amazon SageMaker mit ModelBuilder

Die Vorbereitung Ihres Modells für die Bereitstellung auf einem SageMaker Endpunkt erfordert mehrere Schritte, darunter die Auswahl eines Modell-Images, die Einrichtung der Endpunktkonfiguration, die Codierung Ihrer Serialisierungs- und Deserialisierungsfunktionen für die Übertragung von Daten zu und von Server und Client, die Identifizierung von Modellabhängigkeiten und deren Upload auf Amazon S3. ModelBuilderkann die Komplexität der Ersteinrichtung und Bereitstellung reduzieren, sodass Sie in einem einzigen Schritt ein einsatzfähiges Modell erstellen können.

ModelBuilderführt die folgenden Aufgaben für Sie aus:

Erstellen Sie Ihr Modell mit ModelBuilder

ModelBuilderist eine Python-Klasse, die ein Framework-Modell wie XGBoost oder oder oder PyTorch eine benutzerdefinierte Inferenzspezifikation verwendet und es in ein bereitstellbares Modell konvertiert. ModelBuilderstellt eine Build-Funktion bereit, die die Artefakte für die Bereitstellung generiert. Das generierte Modellartefakt ist spezifisch für den Modellserver, den Sie auch als eine der Eingaben angeben können. Weitere Informationen zur ModelBuilder Klasse finden Sie unter ModelBuilder.

Das folgende Diagramm veranschaulicht den gesamten Arbeitsablauf bei der Modellerstellung bei Verwendung vonModelBuilder. ModelBuilderakzeptiert eine Modell- oder Inferenzspezifikation zusammen mit Ihrem Schema, um ein bereitstellbares Modell zu erstellen, das Sie vor der Bereitstellung lokal testen können.

ModelBuilderkann jede Anpassung vornehmen, die Sie anwenden möchten. Um ein Framework-Modell bereitzustellen, erwartet der Model Builder jedoch mindestens ein Modell, Beispieleingabe und -ausgabe sowie die Rolle. Im folgenden Codebeispiel ModelBuilder wird mit einem Framework-Modell und einer Instanz von SchemaBuilder mit minimalen Argumenten aufgerufen (um die entsprechenden Funktionen für die Serialisierung und Deserialisierung der Endpunkteingabe und -ausgabe abzuleiten). Es ist kein Container angegeben und es werden keine Paketabhängigkeiten übergeben — leitet diese Ressourcen SageMaker automatisch ab, wenn Sie Ihr Modell erstellen.

from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder

model_builder = ModelBuilder(
    model=model,
    schema_builder=SchemaBuilder(input, output),
    role_arn="execution-role",
)

Das folgende Codebeispiel wird ModelBuilder mit einer Inferenzspezifikation (als InferenceSpec Instanz) statt mit einem Modell aufgerufen und bietet zusätzliche Anpassungen. In diesem Fall beinhaltet der Aufruf von Model Builder einen Pfad zum Speichern von Modellartefakten und aktiviert außerdem die automatische Erfassung aller verfügbaren Abhängigkeiten. Weitere Informationen zu finden Sie InferenceSpec unterPassen Sie das Laden von Modellen und die Bearbeitung von Anfragen an.

model_builder = ModelBuilder(
    mode=Mode.LOCAL_CONTAINER,
    model_path=model-artifact-directory,
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(input, output),
    role_arn=execution-role,
    dependencies={"auto": True}
)

Definieren Sie Serialisierungs- und Deserialisierungsmethoden

Beim Aufrufen eines SageMaker Endpunkts werden die Daten über HTTP Payloads verschiedener Typen gesendet. MIME Beispielsweise muss ein Bild, das zur Inferenz an den Endpunkt gesendet wird, auf der Clientseite in Byte konvertiert und über eine HTTP Nutzlast an den Endpunkt gesendet werden. Wenn der Endpunkt die Nutzdaten empfängt, muss er die Bytezeichenfolge wieder auf den Datentyp deserialisieren, der vom Modell erwartet wird (auch als serverseitige Deserialisierung bezeichnet). Nachdem das Modell die Vorhersage abgeschlossen hat, müssen die Ergebnisse auch in Byte serialisiert werden, die dann über die HTTP Nutzlast an den Benutzer oder den Client zurückgesendet werden können. Sobald der Client die Antwortbytedaten empfangen hat, muss er eine clientseitige Deserialisierung durchführen, um die Bytedaten wieder in das erwartete Datenformat zu konvertieren, z. B. JSON Sie müssen mindestens Daten für die folgenden Aufgaben konvertieren:

Das folgende Diagramm zeigt die Serialisierungs- und Deserialisierungsprozesse, die beim Aufrufen des Endpunkts ablaufen.

Wenn Sie Beispieleingabe und -ausgabe bereitstellenSchemaBuilder, generiert der Schema Builder die entsprechenden Marshalling-Funktionen für die Serialisierung und Deserialisierung der Eingabe und Ausgabe. Sie können Ihre Serialisierungsfunktionen mit weiter anpassen. CustomPayloadTranslator In den meisten Fällen würde jedoch ein einfacher Serializer wie der folgende funktionieren:

input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)

Weitere Informationen zu finden Sie unterSchemaBuilder. SchemaBuilder

Der folgende Codeausschnitt beschreibt ein Beispiel, in dem Sie sowohl die Serialisierungs- als auch die Deserialisierungsfunktionen auf Client- und Serverseite anpassen möchten. Sie können Ihre eigenen Anfrage- und Antwortübersetzer mit definieren und diese Übersetzer an sie CustomPayloadTranslator weiterleiten. SchemaBuilder

Indem er die Eingaben und Ausgaben mit den Übersetzern zusammenführt, kann der Modellbauer das Datenformat extrahieren, das das Modell erwartet. Nehmen wir beispielsweise an, dass es sich bei der Beispieleingabe um ein Rohbild handelt und Ihre benutzerdefinierten Übersetzer das Bild zuschneiden und das zugeschnittene Bild als Tensor an den Server senden. ModelBuilderbenötigt sowohl die Roheingabe als auch jeglichen benutzerdefinierten Vor- oder Nachverarbeitungscode, um eine Methode zur Konvertierung von Daten sowohl auf der Client- als auch auf der Serverseite abzuleiten.

from sagemaker.serve import CustomPayloadTranslator

# request translator
class MyRequestTranslator(CustomPayloadTranslator):
    # This function converts the payload to bytes - happens on client side
    def serialize_payload_to_bytes(self, payload: object) -> bytes:
        # converts the input payload to bytes
        ... ...
        return  //return object as bytes

    # This function converts the bytes to payload - happens on server side
    def deserialize_payload_from_stream(self, stream) -> object:
        # convert bytes to in-memory object
        ... ...
        return //return in-memory object

# response translator
class MyResponseTranslator(CustomPayloadTranslator):
    # This function converts the payload to bytes - happens on server side
    def serialize_payload_to_bytes(self, payload: object) -> bytes:
        # converts the response payload to bytes
        ... ...
        return //return object as bytes

    # This function converts the bytes to payload - happens on client side
    def deserialize_payload_from_stream(self, stream) -> object:
        # convert bytes to in-memory object
        ... ...
        return //return in-memory object

Sie übergeben die Beispieleingabe und -ausgabe zusammen mit den zuvor definierten benutzerdefinierten Übersetzern, wenn Sie das SchemaBuilder Objekt erstellen, wie im folgenden Beispiel gezeigt:

my_schema = SchemaBuilder(
    sample_input=image,
    sample_output=output,
    input_translator=MyRequestTranslator(),
    output_translator=MyResponseTranslator()
)

Anschließend übergeben Sie die Beispieleingabe und -ausgabe zusammen mit den zuvor definierten benutzerdefinierten Übersetzern an das Objekt. SchemaBuilder

my_schema = SchemaBuilder(
    sample_input=image,
    sample_output=output,
    input_translator=MyRequestTranslator(),
    output_translator=MyResponseTranslator()
)

In den folgenden Abschnitten wird detailliert erklärt, wie Sie Ihr Modell mit den unterstützenden Klassen erstellen ModelBuilder und die zugehörigen Klassen verwenden, um das Erlebnis an Ihren Anwendungsfall anzupassen.

Passen Sie das Laden von Modellen und die Bearbeitung von Anfragen an

Die Bereitstellung Ihres eigenen Inferenzcodes InferenceSpec bietet eine zusätzliche Anpassungsebene. Mit können Sie anpassenInferenceSpec, wie das Modell geladen wird und wie es eingehende Inferenzanfragen verarbeitet, wobei Sie die standardmäßigen Lade- und Inferenzbehandlungsmechanismen umgehen. Diese Flexibilität ist besonders vorteilhaft, wenn Sie mit nicht standardmäßigen Modellen oder benutzerdefinierten Inferenz-Pipelines arbeiten. Sie können die invoke Methode anpassen, um zu steuern, wie das Modell eingehende Anfragen vor- und nachverarbeitet. Die invoke Methode stellt sicher, dass das Modell Inferenzanforderungen korrekt verarbeitet. Das folgende Beispiel wird verwendetInferenceSpec, um ein Modell mit der HuggingFace Pipeline zu generieren. Weitere Informationen zu InferenceSpec finden Sie in der InferenceSpec.

from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline

class MyInferenceSpec(InferenceSpec):
    def load(self, model_dir: str):
        return pipeline("translation_en_to_fr", model="t5-small")

    def invoke(self, input, model):
        return model(input)

inf_spec = MyInferenceSpec()

model_builder = ModelBuilder(
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(X_test, y_pred)
)

Das folgende Beispiel zeigt eine individuellere Variante eines vorherigen Beispiels. Ein Modell wird mit einer Inferenzspezifikation definiert, die Abhängigkeiten aufweist. In diesem Fall ist der Code in der Inferenzspezifikation vom Lang-Segment-Paket abhängig. Das Argument for dependencies enthält eine Anweisung, die den Builder anweist, Lang-Segment mit Git zu installieren. Da der Model Builder vom Benutzer angewiesen wird, eine Abhängigkeit individuell zu installieren, besteht der auto Schlüssel darin, die automatische Erfassung von Abhängigkeiten False zu deaktivieren.

model_builder = ModelBuilder(
    mode=Mode.LOCAL_CONTAINER,
    model_path=model-artifact-directory,
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(input, output),
    role_arn=execution-role,
    dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)

Erstellen Sie Ihr Modell und stellen Sie es bereit

Rufen Sie die build Funktion auf, um Ihr einsatzfähiges Modell zu erstellen. Dieser Schritt erstellt Inferenzcode (asinference.py) in Ihrem Arbeitsverzeichnis mit dem Code, der zum Erstellen Ihres Schemas, zum Ausführen der Serialisierung und Deserialisierung von Eingaben und Ausgaben sowie zum Ausführen anderer benutzerdefinierter benutzerdefinierter Logik erforderlich ist.

Zur Integritätsprüfung werden die für die Bereitstellung im Rahmen der Build-Funktion erforderlichen Dateien SageMaker gepackt und ausgewählt. ModelBuilder Während dieses Vorgangs erstellt es SageMaker auch eine HMAC Signatur für die Pickle-Datei und fügt den geheimen Schlüssel während deploy (odercreate) CreateModelAPIals Umgebungsvariable hinzu. Beim Endpunktstart wird die Umgebungsvariable verwendet, um die Integrität der Pickle-Datei zu überprüfen.

# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()

Stellen Sie Ihr Modell mit der vorhandenen deploy Methode des Modells bereit. In diesem Schritt SageMaker richtet es einen Endpunkt ein, auf dem Ihr Modell gehostet wird, wenn es anfängt, Vorhersagen für eingehende Anfragen zu treffen. Der leitet zwar die ModelBuilder Endpunktressourcen ab, die für die Bereitstellung Ihres Modells benötigt werden, Sie können diese Schätzungen jedoch mit Ihren eigenen Parameterwerten überschreiben. Das folgende Beispiel weist darauf SageMaker hin, dass das Modell auf einer einzigen ml.c6i.xlarge Instanz bereitgestellt werden soll. Ein daraus erstelltes Modell ModelBuilder ermöglicht als zusätzliche Funktion die Live-Protokollierung während der Bereitstellung.

predictor = model.deploy(
    initial_instance_count=1,
    instance_type="ml.c6i.xlarge"
)

Wenn Sie eine genauere Kontrolle über die Ihrem Modell zugewiesenen Endpunktressourcen wünschen, können Sie ein ResourceRequirements Objekt verwenden. Mit dem ResourceRequirements Objekt können Sie eine Mindestanzahl von Beschleunigern und Kopien von CPUs Modellen anfordern, die Sie bereitstellen möchten. Sie können auch eine Mindest- und Höchstmenge an Arbeitsspeicher (in MB) anfordern. Um diese Funktion verwenden zu können, müssen Sie Ihren Endpunkttyp als angebenEndpointType.INFERENCE_COMPONENT_BASED. Im folgenden Beispiel müssen vier Beschleuniger, eine Mindestspeichergröße von 1024 MB und eine Kopie Ihres Modells auf einem Endpunkt des Typs EndpointType.INFERENCE_COMPONENT_BASED bereitgestellt werden.

resource_requirements = ResourceRequirements(
    requests={
        "num_accelerators": 4,
        "memory": 1024,
        "copies": 1,
    },
    limits={},
)
predictor = model.deploy(
    mode=Mode.SAGEMAKER_ENDPOINT,
    endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
    resources=resource_requirements,
    role="role"
)

Bringen Sie Ihren eigenen Behälter mit () BYOC

Wenn Sie Ihren eigenen Container (aus einem SageMaker Container erweitert) mitbringen möchten, können Sie das Bild auch URI wie im folgenden Beispiel angeben. Sie müssen auch den Modellserver identifizieren, der dem Bild entspricht, um Artefakte ModelBuilder zu generieren, die für den Modellserver spezifisch sind.

model_builder = ModelBuilder(
    model=model,
    model_server=ModelServer.TORCHSERVE,
    schema_builder=SchemaBuilder(X_test, y_pred),
    image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)

Verwendung ModelBuilder im lokalen Modus

Sie können Ihr Modell lokal bereitstellen, indem Sie das mode Argument verwenden, um zwischen lokalem Testen und der Bereitstellung auf einem Endpunkt zu wechseln. Sie müssen die Modellartefakte im Arbeitsverzeichnis speichern, wie im folgenden Codeausschnitt dargestellt:

model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")

Übergeben Sie das Modellobjekt, eine SchemaBuilder Instanz, und setzen Sie den Modus auf. Mode.LOCAL_CONTAINER Wenn Sie die build Funktion aufrufen, identifiziert sie ModelBuilder automatisch den unterstützten Framework-Container und sucht nach Abhängigkeiten. Das folgende Beispiel zeigt die Modellerstellung mit einem XGBoost Modell im lokalen Modus.

model_builder_local = ModelBuilder(
    model=model,
    schema_builder=SchemaBuilder(X_test, y_pred),
    role_arn=execution-role,
    mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()

Rufen Sie die deploy Funktion zur lokalen Bereitstellung auf, wie im folgenden Codeausschnitt gezeigt. Wenn Sie Parameter für Instanztyp oder Anzahl angeben, werden diese Argumente ignoriert.

predictor_local = xgb_local_builder.deploy()

Problembehandlung im lokalen Modus

Abhängig von Ihrer individuellen lokalen Konfiguration können Probleme beim ModelBuilder reibungslosen Betrieb in Ihrer Umgebung auftreten. In der folgenden Liste finden Sie einige Probleme, mit denen Sie möglicherweise konfrontiert werden, und wie Sie sie lösen können.

ModelBuilder Beispiele

Weitere Beispiele für die Verwendung ModelBuilder beim Erstellen Ihrer Modelle finden Sie unter ModelBuilderBeispielnotizbücher.