Erste Schritte / Praktische Übungen / ...
Deploy a Machine Learning Model for Inference (Bereitstellen eines Machine-Learning-Modells für einen Echtzeit-Inferenz-Endpunkt)
TUTORIAL
Übersicht
In diesem Tutorial lernen Sie, wie Sie ein trainiertes Machine Learning (ML)-Modell mit Amazon SageMaker Studio an einem Echtzeit-Inferenz-Endpunkt bereitstellen.
SageMaker Studio ist eine integrierte Entwicklungsumgebung (IDE) für ML, welche eine vollständig verwaltete Jupyter-Notebook-Schnittstelle bietet, in der Sie den gesamten ML-Lebenszyklus, einschließlich der Modellbereitstellung, durchführen können.
SageMaker bietet verschiedene Inferenzoptionen für die Unterstützung einer breiten Palette von Anwendungsfällen:
- SageMaker Real-Time Inference für Workloads mit Anforderungen an niedrige Latenzzeiten im Millisekundenbereich
- SageMaker Serverless Inference für Workloads mit intermittierendem oder unregelmäßigem Datenverkehr
- SageMaker Asynchronous Inference für Inferenzen mit großer Nutzlast oder mit Bedarf an langen Verarbeitungszeiten
- SageMaker batch transform, um Prognosen für Datenstapel durchzuführen
In diesem Tutorial werden Sie die Option Echtzeit-Inferenz verwenden, um ein binäres XGBoost-Klassifizierungsmodell einzusetzen, das schon auf einem synthetischen Datensatz für Kfz-Versicherungsansprüche trainiert worden ist. Der Datensatz besteht aus Details und extrahierten Merkmalen aus Schaden- und Kundentabellen, sowie einer Betrugsspalte, die angibt, ob ein Schaden betrügerisch war oder nicht. Das Modell sagt die Wahrscheinlichkeit voraus, dass ein Antrag betrügerisch ist. Sie schlüpfen in die Rolle eines Machine-Learning-Ingenieurs, der dieses Modell einsetzt und Beispiel-Inferenzen durchführt.
Was Sie erreichen werden
In diesem Leitfaden werden Sie:
- Ein Modell in SageMaker aus einem trainierten Modell-Artefakt erstellen
- Einen Endpunkt für Echtzeit-Inferenz konfigurieren und einsetzen, um das Modell zu bedienen
- Den Endpunkt aufrufen, um Stichprobenvorhersagen mit Testdaten durchzuführen
- Dem Endpunkt eine Autoskalierungs-Richtlinie zuweisen, um Verkehrsänderungen zu verarbeiten
Voraussetzungen
Bevor Sie mit diesem Leitfaden beginnen, benötigen Sie:
- Ein AWS-Konto: Wenn Sie noch keins haben, folgen Sie der Anleitung zum Einrichten Ihrer Umgebung, um einen schnellen Überblick zu erhalten.
Erfahrung mit AWS
Einsteiger
Benötigte Zeit
25 Minuten
Kosten für die Fertigstellung
Siehe SageMaker-Preise, um die Kosten für dieses Tutorial abzuschätzen.
Erfordert
Sie müssen in einem AWS-Konto angemeldet sein.
Verwendete Services
Amazon SageMaker Real-time Inference, Amazon SageMaker Studio
Letzte Aktualisierung
19. Mai 2022
Implementierung
Schritt 1: Richten Sie Ihre Domäne von Amazon SageMaker Studio ein
Mit Amazon SageMaker können Sie ein Modell visuell über die Konsole oder programmtechnisch über SageMaker Studio oder SageMaker Notebooks bereitstellen. In diesem Tutorial stellen Sie das Modell programmgesteuert mithilfe eines SageMaker-Studio-Notebooks bereit, wofür eine SageMaker-Studio-Domäne erforderlich ist.
Ein AWS-Konto kann nur eine SageMaker-Studio-Domäne pro Region haben. Wenn Sie bereits über eine SageMaker-Studio-Domäne in der Region USA Ost (Nord-Virginia) verfügen, befolgen Sie die Anleitung zur Einrichtung von SageMaker Studio, um die erforderlichen AWS-IAM-Richtlinien mit Ihrem Konto von SageMaker Studio zu verknüpfen, überspringen Sie dann Schritt 1 und fahren Sie direkt mit Schritt 2 fort.
Wenn Sie keine bestehende SageMaker-Studio-Domäne haben, fahren Sie mit Schritt 1 fort, um eine AWS-CloudFormation-Vorlage auszuführen, die eine SageMaker-Studio-Domäne erstellt und die für den Rest dieses Tutorials erforderlichen Berechtigungen hinzufügt.
Wählen Sie den Link für AWS-CloudFormation-Stack. Dieser Link öffnet die AWS-CloudFormation-Konsole und erstellt Ihre SageMaker-Studio-Domäne und einen Benutzer namens studio-user . Er fügt auch die erforderlichen Berechtigungen zu Ihrem Konto von SageMaker Studio hinzu. Bestätigen Sie in der CloudFormation-Konsole, dass USA Ost (Nord-Virginia) die Region ist, die in der oberen rechten Ecke angezeigt wird. Der Stack-Name sollte CFN-SM-IM-Lambda-Catalog lauten und nicht geändert werden. Dieser Stack benötigt etwa 10 Minuten, um alle Ressourcen zu erstellen.
Dieser Stack geht davon aus, dass Sie bereits eine öffentliche VPC in Ihrem Konto eingerichtet haben. Wenn Sie keine öffentliche VPC haben, lesen Sie VPC mit einem einzigen öffentlichen Subnetz, um zu erfahren, wie Sie eine öffentliche VPC erstellen können.
Wählen Sie Ich bestätige, dass AWS CloudFormation möglicherweise IAM-Ressourcen erstellt und wählen Sie dann Stack erstellen.
Wählen Sie im Bereich CloudFormation die Option Stacks. Es dauert etwa 10 Minuten, bis der Stack erstellt ist. Wenn der Stapel erstellt wird, ändert sich der Status des Stapels von CREATE_IN_PROGRESS zu CREATE_COMPLETE.
Schritt 2: Einrichten eines SageMaker-Studio-Notebooks
In diesem Schritt starten Sie ein neues SageMaker-Studio-Notebook, installieren die erforderlichen Open-Source-Bibliotheken und konfigurieren die für den Abruf des trainierten Modell-Artefakts vom Amazon Simple Storage Service (Amazon S3) erforderlichen SageMaker-Variablen. Weil das Modell-Artefakt aber nicht direkt zur Inferenz eingesetzt werden kann, müssen Sie zunächst ein SageMaker-Modell aus dem Modell-Artefakt erstellen. Das erstellte Modell wird den Code für Training und Inferenz enthalten, den SageMaker für den Einsatz des Modells verwenden wird.
Geben Sie SageMaker Studio in die Suchleiste der AWS-Konsole ein und wählen Sie dann SageMaker Studio.
Wählen Sie USA Ost (Nord-Virginia) aus der Dropdown-Liste Region in der oberen rechten Ecke der Konsole aus. Wählen Sie für Anwendung starten die Option Studio, um SageMaker Studio mit dem studio-user-Profil zu öffnen.
Öffnen Sie die Oberfläche von SageMaker Studio. Wählen Sie in der Navigationsleiste Datei, Neu, Notebook.
Wählen Sie im Dialogfeld Notebook-Umgebung einrichten unter Image die Option Datenwissenschaft. Der Python 3-Kernel wird automatisch ausgewählt. Wählen Sie Auswählen aus.
Der Kernel in der oberen rechten Ecke des Notizbuchs sollte nun Python 3 (Datenwissenschaft) anzeigen.
Kopieren Sie den folgenden Codeschnipsel und fügen Sie ihn in eine Zelle des Notebooks ein. Drücken Sie Umschalt+Eingabe, um die aktuelle Zelle auszuführen und die aiobotocore-Bibliothek zu aktualisieren, welche eine API zur Interaktion mit vielen AWS-Services ist. Ignorieren Sie alle Warnungen, den Kernel neu zu starten, und alle Fehlermeldungen zu Abhängigkeitskonflikten.
%pip install --upgrade -q aiobotocoreSie müssen auch das S3-Client-Objekt und die Speicherorte innerhalb Ihres Standard-S3-Buckets instanzieren, in welches die Metriken und Modell-Artefakte hochgeladen werden. Kopieren Sie dazu den folgenden Code, fügen Sie ihn in eine Zelle des Notebooks ein und führen Sie ihn aus. Beachten Sie, dass der Schreib-Bucket sagemaker-<Ihre-Region>-<Ihre-Konto-ID> automatisch durch das SageMaker-Sitzung sobjekt in Zeile 16 des folgenden Codes erstellt wird. Die Datensätze, die Sie für das Training verwenden, befinden sich in einem öffentlichen S3-Bucket namens sagemaker-sample-files , der in Zeile 29 als Lese-Bucket festgelegt wurde. Der Ort innerhalb des Buckets wird durch das Lesepräfix angegeben.
import pandas as pd
import numpy as np
import boto3
import sagemaker
import time
import json
import io
from io import StringIO
import base64
import pprint
import re
from sagemaker.image_uris import retrieve
sess = sagemaker.Session()
write_bucket = sess.default_bucket()
write_prefix = "fraud-detect-demo"
region = sess.boto_region_name
s3_client = boto3.client("s3", region_name=region)
sm_client = boto3.client("sagemaker", region_name=region)
sm_runtime_client = boto3.client("sagemaker-runtime")
sm_autoscaling_client = boto3.client("application-autoscaling")
sagemaker_role = sagemaker.get_execution_role()
# S3 locations used for parameterizing the notebook run
read_bucket = "sagemaker-sample-files"
read_prefix = "datasets/tabular/synthetic_automobile_claims"
model_prefix = "models/xgb-fraud"
data_capture_key = f"{write_prefix}/data-capture"
# S3 location of trained model artifact
model_uri = f"s3://{read_bucket}/{model_prefix}/fraud-det-xgb-model.tar.gz"
# S3 path where data captured at endpoint will be stored
data_capture_uri = f"s3://{write_bucket}/{data_capture_key}"
# S3 location of test data
test_data_uri = f"s3://{read_bucket}/{read_prefix}/test.csv"Schritt 3: Erstellen eines Echtzeit-Inferenz-Endpunkts
In SageMaker gibt es mehrere Methoden, um ein trainiertes Modell an einem Echtzeit-Inferenz-Endpunkt bereitzustellen: SageMaker SDK, AWS SDK – Boto3, und SageMaker-Konsole. Weitere Informationen finden Sie unter Bereitstellen von Modellen für Inferenz im Entwicklerhandbuch für Amazon SageMaker. Das SageMaker-SDK verfügt über mehr Abstraktionen als das AWS-SDK Boto3, wobei letzteres untergeordnete APIs für eine bessere Kontrolle der Modellbereitstellung bereitstellt. In diesem Tutorial stellen Sie das Modell mit dem AWS-SDK-Boto3 bereit. Es sind drei Schritte, die Sie nacheinander ausführen müssen, um ein Modell einzusetzen:
- Ein Modell in SageMaker vom Modell-Artefakt erstellen
- Erstellen einer Endpunktkonfiguration zur Angabe von Eigenschaften, einschließlich Instance-Typ und Anzahl
- Den Endpunkt mit Hilfe der Endpunktkonfiguration erstellen
Um ein SageMaker-Modell unter Verwendung des in S3 gespeicherten trainierten Modell-Artefakts zu erstellen, kopieren Sie den folgenden Code und fügen ihn ein. Die create_model-Methode nimmt den Docker-Container, der das Trainings-Image enthält (für dieses Modell den XGBoost-Container), und den S3-Speicherort des Modell-Artefakts als Parameter an.
# Retrieve the SageMaker managed XGBoost image
training_image = retrieve(framework="xgboost", region=region, version="1.3-1")
# Specify a unique model name that does not exist
model_name = "fraud-detect-xgb"
primary_container = {
"Image": training_image,
"ModelDataUrl": model_uri
}
model_matches = sm_client.list_models(NameContains=model_name)["Models"]
if not model_matches:
model = sm_client.create_model(ModelName=model_name,
PrimaryContainer=primary_container,
ExecutionRoleArn=sagemaker_role)
else:
print(f"Model with name {model_name} already exists! Change model name to create new")
Sie können das erstellte Modell in der SageMaker-Konsole unter dem Abschnitt Modelle überprüfen.
Nach der Erstellung des SageMaker-Modells kopieren Sie den folgenden Code und fügen ihn ein, um die Boto3-Methode create_endpoint_config zur Konfiguration des Endpunkts zu verwenden. Die wichtigsten Eingaben in die create_endpoint_config-Methode sind der Name der Endpunktkonfiguration und Varianteninformationen, wie z. B. Typ und Anzahl der Inferenz-Instances, der Name des bereitzustellenden Modells und der Verkehrsanteil, den der Endpunkt verarbeiten soll. Gleichzeitig mit diesen Einstellungen können Sie auch die Datenerfassung einrichten, indem Sie eine DataCaptureConfig angeben. Diese Funktion ermöglicht es Ihnen, den Echtzeit-Endpunkt so zu konfigurieren, dass die Anfragen und/oder Antworten in Amazon S3 erfasst und gespeichert werden. Die Datenerfassung ist einer der Schritte bei der Einrichtung der Modellüberwachung und hilft Ihnen, in Kombination mit Baseline-Metriken und Überwachungsaufträgen, bei der Überwachung der Modellleistung durch den Abgleich von Testdatenmetriken mit Baselines. Diese Überwachung ist nützlich für die Planung von Modellumschulungen auf der Basis von Modell- oder Datenabweichungen, sowie für Prüfungszwecke. In der aktuellen Konfiguration werden sowohl die Eingabe (eingehende Testdaten) als auch die Ausgabe (Modellvorhersagen) erfasst und in Ihrem Standard-S3-Bucket gespeichert.
# Endpoint Config name
endpoint_config_name = f"{model_name}-endpoint-config"
# Endpoint config parameters
production_variant_dict = {
"VariantName": "Alltraffic",
"ModelName": model_name,
"InitialInstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"InitialVariantWeight": 1
}
# Data capture config parameters
data_capture_config_dict = {
"EnableCapture": True,
"InitialSamplingPercentage": 100,
"DestinationS3Uri": data_capture_uri,
"CaptureOptions": [{"CaptureMode" : "Input"}, {"CaptureMode" : "Output"}]
}
# Create endpoint config if one with the same name does not exist
endpoint_config_matches = sm_client.list_endpoint_configs(NameContains=endpoint_config_name)["EndpointConfigs"]
if not endpoint_config_matches:
endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[production_variant_dict],
DataCaptureConfig=data_capture_config_dict
)
else:
print(f"Endpoint config with name {endpoint_config_name} already exists! Change endpoint config name to create new")Die erstellte Endpunktkonfiguration können Sie in der SageMaker-Konsole unter dem Abschnitt Endpunktkonfigurationen überprüfen.
Kopieren Sie den folgenden Code und fügen Sie ihn ein, um den Endpunkt zu erstellen. Die create_endpoint-Methode übernimmt die Endpunktkonfiguration als Parameter und stellt das in der Endpunktkonfiguration angegebene Modell in einer Compute-Instance bereit. Es dauert etwa 6 Minuten, das Modell bereitzustellen.
endpoint_name = f"{model_name}-endpoint"
endpoint_matches = sm_client.list_endpoints(NameContains=endpoint_name)["Endpoints"]
if not endpoint_matches:
endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name
)
else:
print(f"Endpoint with name {endpoint_name} already exists! Change endpoint name to create new")
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp["EndpointStatus"]
while status == "Creating":
print(f"Endpoint Status: {status}...")
time.sleep(60)
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp["EndpointStatus"]
print(f"Endpoint Status: {status}")Um den Status des Endpunkts zu überprüfen, wählen Sie das Symbol für SageMaker-Ressourcen. Wählen Sie für SageMaker-Ressourcen die Option Endpunkte und für Name die Option fraud-detect-xgb-endpoint.
Schritt 4: Aufrufen des Inferenzendpunkts
Nachdem der Endpunktstatus auf InService geändert ist, können Sie den Endpunkt über die REST-API, AWS SDK – Boto3, SageMaker Studio, AWS CLI oder SageMaker Python SDK aufrufen. In diesem Tutorial verwenden Sie das AWS-SDK – Boto3. Es ist wichtig, dass die Testdaten vor dem Aufruf eines Endpunkts durch Serialisierung und Deserialisierung für den Endpunkt geeignet formatiert werden. Unter Serialisierung versteht man die Umwandlung von Rohdaten in einem Format wie .csv in Byte-Ströme, die der Endpunkt verwenden kann. Die Deserialisierung ist der umgekehrte Prozess der Umwandlung eines Byte-Stroms in ein für Menschen lesbares Format. In diesem Tutorial rufen Sie den Endpunkt auf, indem Sie die ersten fünf Proben aus einem Testdatensatz senden. Um den Endpunkt aufzurufen und Vorhersageergebnisse zu erhalten, kopieren Sie den folgenden Code und fügen ihn ein. Weil die Anfrage an den Endpunkt (Testdatensatz) im .csv-Format vorliegt, wird ein csv-Serialisierungsprozess verwendet, um die Nutzlast zu erstellen. Die Antwort wird dann in ein Array von Vorhersagen deserialisiert. Nach Abschluss der Ausführung gibt die Zelle die Modellvorhersagen und die echten Bezeichnungen für die Testproben zurück. Beachten Sie, dass das XGBoost-Modell Wahrscheinlichkeiten anstelle von tatsächlichen Klassenbezeichnungen liefert. Das Modell hat eine sehr geringe Wahrscheinlichkeit vorhergesagt, dass es sich bei den Testproben um betrügerische Anträge handelt, und die Vorhersagen stimmen mit den tatsächlichen Kennzeichnungen überein.
# Fetch test data to run predictions with the endpoint
test_df = pd.read_csv(test_data_uri)
# For content type text/csv, payload should be a string with commas separating the values for each feature
# This is the inference request serialization step
# CSV serialization
csv_file = io.StringIO()
test_sample = test_df.drop(["fraud"], axis=1).iloc[:5]
test_sample.to_csv(csv_file, sep=",", header=False, index=False)
payload = csv_file.getvalue()
response = sm_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
Body=payload,
ContentType="text/csv",
Accept="text/csv"
)
# This is the inference response deserialization step
# This is a bytes object
result = response["Body"].read()
# Decoding bytes to a string
result = result.decode("utf-8")
# Converting to list of predictions
result = re.split(",|\n",result)
prediction_df = pd.DataFrame()
prediction_df["Prediction"] = result[:5]
prediction_df["Label"] = test_df["fraud"].iloc[:5].values
prediction_df
Öffnen Sie die SageMaker-Konsole, um die Metriken der Endpunktaufrufe mit Amazon CloudWatch zu überwachen. Wählen Sie unter Inferenz die Option Endpunkte, fraud-detect-xgb-endpoint.
Wählen Sie auf der Seite Endpunktdetails unter Monitor die Option Aufrufmetriken anzeigen. Am Anfang sehen Sie vielleicht nur einen einzigen Punkt im Kennzahlendiagramm. Nach mehreren Aufrufen sehen Sie jedoch eine Linie, ähnlich der im Beispiels-Screenshot.
Auf der Seite Metriken werden mehrere Endpunkt-Leistungsmetriken angezeigt. Sie können unterschiedliche Zeiträume, wie beispielsweise 1 Stunde oder 3 Stunden, auswählen, um die Endpunktleistung zu visualisieren. Wählen Sie eine beliebige Kennzahl aus, um ihren Trend über den gewählten Zeitraum zu sehen. Im nächsten Schritt wählen Sie eine dieser Metriken aus, um Richtlinien für die automatische Skalierung zu definieren.
Da die Datenerfassung in der Endpunktkonfiguration eingerichtet wurde, können Sie untersuchen, welche Nutzdaten zusammen mit der Antwort an den Endpunkt gesendet wurden. Es braucht einige Zeit, bis die erfassten Daten vollständig in S3 hochgeladen sind. Kopieren Sie den folgenden Code und fügen Sie ihn ein, um zu überprüfen, ob die Datenerfassung abgeschlossen ist.
from sagemaker.s3 import S3Downloader
print("Waiting for captures to show up", end="")
for _ in range(90):
capture_files = sorted(S3Downloader.list(f"{data_capture_uri}/{endpoint_name}"))
if capture_files:
capture_file = S3Downloader.read_file(capture_files[-1]).split("\n")
capture_record = json.loads(capture_file[0])
if "inferenceId" in capture_record["eventMetadata"]:
break
print(".", end="", flush=True)
time.sleep(1)
print()
print(f"Found {len(capture_files)} Data Capture Files:")Die erfassten Daten werden als separate Datei für jeden Endpunktaufruf in S3 in JSON-Zeilen gespeichert, einem durch neue Zeilen getrennten Format zum Speichern strukturierter Daten, bei dem jede Zeile ein JSON-Wert ist. Kopieren Sie den folgenden Code und fügen Sie ihn ein, um die Datenerfassungsdateien abzurufen.
capture_files = sorted(S3Downloader.list(f"{data_capture_uri}/{endpoint_name}"))
capture_file = S3Downloader.read_file(capture_files[0]).split("\n")
capture_record = json.loads(capture_file[0])
capture_record
Kopieren Sie den folgenden Code und fügen Sie ihn ein, um die Daten in den erfassten Dateien mit base64 zu dekodieren. Der Code ruft die fünf Testmuster ab, die als Nutzlast gesendet wurden, sowie ihre Vorhersagen. Diese Funktion ist nützlich, um Endpunktlasten mit Modellantworten zu überprüfen und die Modellleistung zu überwachen.
input_data = capture_record["captureData"]["endpointInput"]["data"]
output_data = capture_record["captureData"]["endpointOutput"]["data"]
input_data_list = base64.b64decode(input_data).decode("utf-8").split("\n")
print(input_data_list)
output_data_list = base64.b64decode(output_data).decode("utf-8").split("\n")
print(output_data_list)
Schritt 5: Konfiguration der automatischen Skalierung für den Endpunkt
Workloads, die Echtzeit-Inferenz-Endpunkte verwenden, haben in der Regel Anforderungen an geringe Latenzzeiten. Außerdem kann es bei Spitzenbelastungen zu CPU-Überlastungen, hohen Latenzzeiten oder Zeitüberschreitungen an den Echtzeit-Inferenz-Endpunkten kommen. Daher ist es wichtig, die Kapazität zu skalieren, um Verkehrsänderungen effizient und mit geringer Latenz bewältigen zu können. Die automatische Skalierung von SageMaker Inference überwacht Ihre Workloads und passt die Anzahl der Instances dynamisch an, um eine gleichbleibende und vorhersehbare Endpunktleistung bei geringen Kosten zu gewährleisten. Wenn der Workload steigt, bringt die automatische Skalierung mehr Instances online. Wenn der Workload sinkt, werden unnötige Instances entfernt, was Ihnen hilft, Ihre Compute-Kosten zu senken. In diesem Tutorial verwenden Sie das AWS-SDK – Boto3, um die automatische Skalierung für Ihren Endpunkt einzurichten. SageMaker bietet verschiedene Arten der automatischen Skalierung: Zielverfolgungsskalierung, Stufenskalierung, Skalierung nach Bedarf und geplante Skalierung. In diesem Tutorial verwenden Sie eine Zielverfolgung-Skalierungsrichtlinie, die ausgelöst wird, wenn eine ausgewählte Skalierungsmetrik über einen ausgewählten Zielschwellenwert steigt.
Die automatische Skalierung kann in zwei Schritten eingerichtet werden. Erstens konfigurieren Sie eine Skalierungsrichtlinie mit Angaben zur minimalen, gewünschten und maximalen Anzahl von Instances pro Endpunkt. Kopieren Sie den folgenden Code und fügen Sie ihn ein, um eine Skalierungsrichtlinie für die Zielverfolgung zu konfigurieren. Die angegebene maximale Anzahl von Instances wird gestartet, wenn der Datenverkehr bestimmte Schwellenwerte überschreitet, welche Sie im nächsten Schritt festlegen.
resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
# SageMaker expects resource id to be provided with the following structure
resource_id = f"endpoint/{endpoint_name}/variant/{resp['ProductionVariants'][0]['VariantName']}"
# Scaling configuration
scaling_config_response = sm_autoscaling_client.register_scalable_target(
ServiceNamespace="sagemaker",
ResourceId=resource_id,
ScalableDimension="sagemaker:variant:DesiredInstanceCount",
MinCapacity=1,
MaxCapacity=2
)Kopieren Sie den folgenden Code und fügen Sie ihn ein, um die Skalierungsrichtlinie zu erstellen. Die gewählte Skalierungsmetrik ist SageMakerVariantInvocationsPerInstance, welche die durchschnittliche Anzahl von Aufrufen jeder Inferenz-Instance für eine Modellvariante pro Minute angibt. Wenn diese Zahl den gewählten Schwellenwert von 5 überschreitet, wird die automatische Skalierung ausgelöst.
# Create Scaling Policy
policy_name = f"scaling-policy-{endpoint_name}"
scaling_policy_response = sm_autoscaling_client.put_scaling_policy(
PolicyName=policy_name,
ServiceNamespace="sagemaker",
ResourceId=resource_id,
ScalableDimension="sagemaker:variant:DesiredInstanceCount",
PolicyType="TargetTrackingScaling",
TargetTrackingScalingPolicyConfiguration={
"TargetValue": 5.0, # Target for avg invocations per minutes
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance",
},
"ScaleInCooldown": 600, # Duration in seconds until scale in
"ScaleOutCooldown": 60 # Duration in seconds between scale out
}
)Kopieren Sie den folgenden Code und fügen Sie ihn ein, um die Details der Skalierungsrichtlinie abzurufen.
response = sm_autoscaling_client.describe_scaling_policies(ServiceNamespace="sagemaker")
pp = pprint.PrettyPrinter(indent=4, depth=4)
for i in response["ScalingPolicies"]:
pp.pprint(i["PolicyName"])
print("")
if("TargetTrackingScalingPolicyConfiguration" in i):
pp.pprint(i["TargetTrackingScalingPolicyConfiguration"])Kopieren Sie den folgenden Code und fügen Sie ihn ein, um einen Belastungstest für den Endpunkt durchzuführen. Der Code läuft 250 Sekunden lang und ruft den Endpunkt wiederholt auf, indem er zufällig ausgewählte Stichproben aus dem Testdatensatz sendet.
request_duration = 250
end_time = time.time() + request_duration
print(f"Endpoint will be tested for {request_duration} seconds")
while time.time() < end_time:
csv_file = io.StringIO()
test_sample = test_df.drop(["fraud"], axis=1).iloc[[np.random.randint(0, test_df.shape[0])]]
test_sample.to_csv(csv_file, sep=",", header=False, index=False)
payload = csv_file.getvalue()
response = sm_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
Body=payload,
ContentType="text/csv"
)Sie können die Endpunktmetriken mit Amazon CloudWatch überwachen. Eine Liste der verfügbaren Endpunktmetriken, einschließlich Aufrufen, finden Sie unter SageMaker Endpunktaufrufmetriken. Wählen Sie in der SageMaker-Konsole unter Inferenz die Option Endpunkte, fraud-detect-xgb-endpoint. Navigieren Sie auf der Seite mit den Endpunktdetails zum Abschnitt Monitor und wählen Sie Aufrufmetriken anzeigen. Wählen Sie auf der Seite Metriken die Metriken InvocationsPerInstance (dies ist eine Überwachungsmetrik, die Sie beim Einrichten der Skalierungsrichtlinie ausgewählt haben) und Aufrufe aus der Liste der Metriken aus, und wählen Sie dann die Registerkarte Graphenmetriken.
Auf der Seite mit den grafischen Metriken können Sie das vom Endpunkt empfangene Verkehrsmuster visuell untersuchen und die zeitliche Granularität ändern, beispielsweise von den standardmäßigen 5 Minuten auf 1 Minute. Es kann ein paar Minuten dauern, bis die automatische Skalierung die zweite Instance hinzufügt. Sobald die neue Instance hinzugefügt wurde, werden Sie feststellen, dass die Aufrufe pro Instance die Hälfte der Gesamtaufrufe ausmachen.
Wenn der Endpunkt die erhöhte Nutzlast erhält, können Sie den Status des Endpunkts überprüfen, indem Sie den folgenden Code ausführen. Dieser Code prüft, wann der Status des Endpunkts von InService zu Updating wechselt und verfolgt die Anzahl der Instances. Nach einigen Minuten können Sie sehen, wie sich der Status von InService zu Updating und wieder zu InService ändert, allerdings mit einer höheren Anzahl von Instances.
# Check the instance counts after the endpoint gets more load
response = sm_client.describe_endpoint(EndpointName=endpoint_name)
endpoint_status = response["EndpointStatus"]
request_duration = 250
end_time = time.time() + request_duration
print(f"Waiting for Instance count increase for a max of {request_duration} seconds. Please re run this cell in case the count does not change")
while time.time() < end_time:
response = sm_client.describe_endpoint(EndpointName=endpoint_name)
endpoint_status = response["EndpointStatus"]
instance_count = response["ProductionVariants"][0]["CurrentInstanceCount"]
print(f"Status: {endpoint_status}")
print(f"Current Instance count: {instance_count}")
if (endpoint_status=="InService") and (instance_count>1):
break
else:
time.sleep(15)
Schritt 6: Bereinigung der Ressourcen
Es ist eine bewährte Methode, Ressourcen zu löschen, die Sie nicht mehr verwenden, damit Ihnen keine unbeabsichtigten Kosten entstehen.
Löschen Sie das Modell, die Endpunktkonfiguration und den Endpunkt, die Sie in diesem Tutorial erstellt haben, indem Sie den folgenden Codeblock in Ihrem Notebook ausführen. Wenn Sie den Endpunkt nicht löschen, sammelt Ihr Konto weiterhin Gebühren für die am Endpunkt laufende Compute-Instance an.
# Delete model
sm_client.delete_model(ModelName=model_name)
# Delete endpoint configuration
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
# Delete endpoint
sm_client.delete_endpoint(EndpointName=endpoint_name)Um den S3-Bucket zu löschen, machen Sie Folgendes:
- Öffnen Sie die Amazon-S3-Konsole. Wählen Sie in der Navigationsleiste Buckets, sagemaker-<Ihre-Region>-<Ihre-Konto-ID>, und aktivieren Sie dann das Kontrollkästchen neben fraud-detect-demo. Wählen Sie dann Löschen.
- Im Dialogfeld Objekte löschen vergewissern Sie sich, dass Sie das richtige Objekt zum Löschen ausgewählt haben, und geben Sie dauerhaft löschen im Bestätigungsfeld Objekte dauerhaft löschen ein.
- Wenn der Vorgang abgeschlossen und der Bucket leer ist, können Sie den Bucket sagemaker-<Ihre Region>-<Ihre Konto-ID> löschen, indem Sie das gleiche Verfahren erneut durchführen.
Der Datenwissenschaftliche Kernel, der für die Ausführung des Notebook-Images in diesem Tutorial verwendet wird, sammelt Gebühren an, bis Sie entweder den Kernel stoppen oder die folgenden Schritte ausführen, um die Anwendungen zu löschen. Weitere Informationen finden Sie unter Herunterfahren von Ressourcen im Entwicklerhandbuch für Amazon SageMaker.
Gehen Sie wie folgt vor, um die SageMaker-Studio-Anwendungen zu löschen: Wählen Sie in der SageMaker-Studio-Konsole studio-user und löschen Sie dann alle unter Anwendungen aufgeführten Anwendungen, indem Sie Anwendung löschen wählen. Warten Sie, bis der Status auf Gelöscht wechselt.
Wenn Sie in Schritt 1 eine bestehende SageMaker-Studio-Domäne verwendet haben, überspringen Sie den Rest von Schritt 6 und fahren Sie direkt mit dem Abschnitt Fazit fort.
Wenn Sie die CloudFormation-Vorlage in Schritt 1 ausgeführt haben, um eine neue SageMaker-Studio-Domäne zu erstellen, fahren Sie mit den folgenden Schritten fort, um die Domäne, den Benutzer und die von der CloudFormation-Vorlage erstellten Ressourcen zu löschen.
Um die CloudFormation-Konsole zu öffnen, geben Sie CloudFormation in die Suchleiste der AWS-Konsole ein, und wählen Sie CloudFormation aus den Suchergebnissen aus.
Wählen Sie im Bereich CloudFormation die Option Stacks. Wählen Sie in der Dropdown-Liste Status die Option Aktiv. Wählen Sie unter Stack-Name die Option CFN-SM-IM-Lambda-catalog, um die Seite mit den Stackdetails zu öffnen.
Wählen Sie auf der Seite CFN-SM-IM-Lambda-catalog Stack-Details die Option Löschen, um den Stack zusammen mit den in Schritt 1 erstellten Ressourcen zu löschen.
Zusammenfassung
Herzlichen Glückwunsch! Sie haben das Tutorial Bereitstellen eines Machine-Learning-Modells für einen Echtzeit-Inferenz-Endpunkt beendet.
In diesem Tutorial haben Sie ein SageMaker-Modell erstellt und es an einem Echtzeit-Inferenz-Endpunkt eingesetzt. Sie haben die API von AWS-SDK – Boto3 verwendet, um den Endpunkt aufzurufen und zu testen, indem Sie Beispielinferenzen ausgeführt und die Datenerfassungsfunktion genutzt haben, um Endpunkt-Payloads und Antworten in S3 zu speichern. Schließlich haben Sie eine automatische Skalierung konfiguriert, indem Sie eine Ziel-Endpunktaufruf-Metrik verwendeten, um Verkehrsschwankungen auszugleichen.
Sie können Ihre Machine-Learning-Reise mit Amazon SageMaker fortsetzen, indem Sie dem Abschnitt Nächste Schritte unten folgen.
Trainieren eines Deep-Learning-Modells
Automatisches Erstellen eines ML-Modells
Weitere Praxis-Tutorials finden