Stellen Sie Amazon SageMaker Autopilot-Modelle an serverlosen Inferenzendpunkten bereit

Amazon SageMaker-Autopilot erstellt, trainiert und optimiert automatisch die besten Modelle für maschinelles Lernen (ML) basierend auf Ihren Daten, während Sie die volle Kontrolle und Transparenz behalten. Autopilot kann auch trainierte Modelle automatisch an Echtzeit-Inferenzendpunkten bereitstellen.

Wenn Sie Workloads mit spitzen oder unvorhersehbaren Datenverkehrsmustern haben, die Kaltstarts tolerieren können, wäre die Bereitstellung des Modells auf einem serverlosen Inferenzendpunkt kosteneffizienter.

Serverlose Amazon SageMaker-Inferenz ist eine speziell entwickelte Inferenzoption, die sich ideal für Workloads mit unvorhersehbaren Datenverkehrsmustern eignet und Kaltstarts tolerieren kann. Im Gegensatz zu einem Echtzeit-Inferenz-Endpunkt, der von einer langlebigen Recheninstanz unterstützt wird, stellen serverlose Endpunkte Ressourcen nach Bedarf mit integrierter automatischer Skalierung bereit. Serverlose Endpunkte skalieren automatisch basierend auf der Anzahl eingehender Anfragen und skalieren Ressourcen auf null herunter, wenn keine eingehenden Anfragen vorhanden sind, was Ihnen hilft, Ihre Kosten zu minimieren.

In diesem Beitrag zeigen wir, wie Sie mit Autopilot trainierte Modelle mithilfe von für serverlose Inferenzendpunkte bereitstellen Boto3-Bibliotheken für Amazon Sage Maker.

Autopilot-Trainingsmodi

Bevor Sie ein Autopilot-Experiment erstellen, können Sie entweder Autopilot den Trainingsmodus automatisch auswählen lassen oder den Trainingsmodus manuell auswählen.

Autopilot unterstützt derzeit drei Trainingsmodi:

• Auto – Basierend auf der Datensatzgröße wählt Autopilot automatisch entweder den Ensembling- oder den HPO-Modus. Für Datensätze größer als 100 MB wählt Autopilot HPO; andernfalls wählt es Ensembling.
• Ensemble – Autopilot verwendet die AutoGluon ensembling-Technik unter Verwendung von Model Stacking und erzeugt ein optimales Vorhersagemodell.
• Hyperparameter-Optimierung (HPO) – Autopilot findet die beste Version eines Modells, indem er Hyperparameter mithilfe von Bayes'scher Optimierung oder Multi-Fidelity-Optimierung optimiert, während er Trainingsjobs auf Ihrem Datensatz ausführt. Der HPO-Modus wählt die Algorithmen aus, die für Ihren Datensatz am relevantesten sind, und wählt den besten Bereich von Hyperparametern aus, um Ihre Modelle zu optimieren.

Weitere Informationen zu den Autopilot-Trainingsmodi finden Sie unter Trainingsmodi.

Lösungsüberblick

In diesem Beitrag verwenden wir die UCI Bankmarketing Datensatz, um vorherzusagen, ob ein Kunde eine von der Bank angebotene Termineinlage abonnieren wird. Dies ist ein Problemtyp für die binäre Klassifizierung.

Wir starten zwei Autopilot-Jobs mit der Boto3-Bibliotheken für SageMaker. Der erste Job verwendet Ensembling als gewählten Trainingsmodus. Anschließend stellen wir das generierte einzelne Ensemble-Modell auf einem serverlosen Endpunkt bereit und senden Rückschlussanforderungen an diesen gehosteten Endpunkt.

Der zweite Job verwendet den HPO-Trainingsmodus. Für Klassifizierungsproblemtypen generiert Autopilot drei Inferenzcontainer. Wir extrahieren diese drei Inferenzcontainer und stellen sie auf separaten serverlosen Endpunkten bereit. Dann senden wir Inferenzanfragen an diese gehosteten Endpunkte.

Weitere Informationen zu Regressions- und Klassifizierungsproblemtypen finden Sie unter Inferenzcontainerdefinitionen für Regressions- und Klassifizierungsproblemtypen.

Wir können Autopilot-Jobs auch von starten Amazon SageMaker-Studio Benutzeroberfläche. Wenn Sie Jobs über die Benutzeroberfläche starten, stellen Sie sicher, dass Sie das deaktivieren Automatische Bereitstellung Option in der Bereitstellung und erweiterte Einstellungen Sektion. Andernfalls stellt Autopilot den besten Kandidaten auf einem Echtzeit-Endpunkt bereit.

Voraussetzungen:

Stellen Sie sicher, dass Sie die neueste Version von Boto3 und die SageMaker-Python-Pakete installiert haben:

pip install -U boto3 sagemaker

Wir benötigen die SageMaker-Paketversion >= 2.110.0 und Boto3-Version >= boto3-1.24.84.

Starten Sie einen Autopilot-Job mit dem Ensembling-Modus

Um einen Autopilot-Job mit den SageMaker Boto3-Bibliotheken zu starten, verwenden wir die create_auto_ml_job API. Wir gehen dann hinein AutoMLJobConfig, InputDataConfig und AutoMLJobObjective als Eingaben für die create_auto_ml_job. Siehe folgenden Code:

bucket = session.default_bucket()
role = sagemaker.get_execution_role()
prefix = "autopilot/bankadditional"
sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

timestamp_suffix = strftime('%d%b%Y-%H%M%S', gmtime())
automl_job_name = f"uci-bank-marketing-{timestamp_suffix}"
max_job_runtime_seconds = 3600
max_runtime_per_job_seconds = 1200
target_column = "y"
problem_type="BinaryClassification"
objective_metric = "F1"
training_mode = "ENSEMBLING"

automl_job_config = {
    'CompletionCriteria': {
      'MaxRuntimePerTrainingJobInSeconds': max_runtime_per_job_seconds,
      'MaxAutoMLJobRuntimeInSeconds': max_job_runtime_seconds
    },    
    "Mode" : training_mode
}

automl_job_objective= { "MetricName": objective_metric }

input_data_config = [
    {
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': f's3://{bucket}/{prefix}/raw/bank-additional-full.csv'
        }
      },
      'TargetAttributeName': target_column
    }
  ]

output_data_config = {
	    'S3OutputPath': f's3://{bucket}/{prefix}/output'
	}


sm_client.create_auto_ml_job(
				AutoMLJobName=auto_ml_job_name,
				InputDataConfig=input_data_config,
				OutputDataConfig=output_data_config,
				AutoMLJobConfig=automl_job_config,
				ProblemType=problem_type,
				AutoMLJobObjective=automl_job_objective,
				RoleArn=role)

Der Autopilot gibt die zurück BestCandidate Modellobjekt, das die hat InferenceContainers erforderlich, um die Modelle auf Inferenzendpunkten bereitzustellen. Um das zu bekommen BestCandidate für den vorherigen Job verwenden wir die describe_automl_job Funktion:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_container = job_response['BestCandidate']['InferenceContainers'][0]
print(inference_container)

Stellen Sie das trainierte Modell bereit

Wir stellen jetzt den vorherigen Inferenzcontainer auf einem serverlosen Endpunkt bereit. Der erste Schritt besteht darin, ein Modell aus dem Inferenzcontainer zu erstellen und dann eine Endpunktkonfiguration zu erstellen, in der wir die angeben MemorySizeInMB und MaxConcurrency -Werte für den serverlosen Endpunkt zusammen mit dem Modellnamen. Abschließend erstellen wir einen Endpunkt mit der oben erstellten Endpunktkonfiguration.

Wir empfehlen Ihnen, Ihre zu wählen Speichergröße des Endpunkts entsprechend Ihrer Modellgröße. Die Speichergröße sollte mindestens so groß sein wie Ihre Modellgröße. Ihr serverloser Endpunkt hat eine RAM-Mindestgröße von 1024 MB (1 GB), und die maximal wählbare RAM-Größe beträgt 6144 MB (6 GB).

Die Speichergrößen, die Sie wählen können, sind 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB oder 6144 MB.

Um festzustellen, ob ein serverloser Endpunkt aus Kosten- und Leistungssicht die richtige Bereitstellungsoption ist, empfehlen wir Ihnen, sich auf die zu beziehen SageMaker Serverless Inference Benchmarking Toolkit, das verschiedene Endpunktkonfigurationen testet und die optimalste mit einer vergleichbaren Echtzeit-Hosting-Instanz vergleicht.

Beachten Sie, dass serverlose Endpunkte nur akzeptieren SingleModel für Inferenzcontainer. Autopilot im Ensembling-Modus generiert ein einzelnes Modell, sodass wir diesen Modellcontainer unverändert auf dem Endpunkt bereitstellen können. Siehe folgenden Code:

# Create Model
	model_response = sm_client.create_model(
				ModelName=model_name,
				ExecutionRoleArn=role,
				Containers=[inference_container]
	)

# Create Endpoint Config
	epc_response = sm_client.create_endpoint_config(
		EndpointConfigName = endpoint_config_name,
		ProductionVariants=[
			{
				"ModelName": model_name,
				"VariantName": "AllTraffic",
				"ServerlessConfig": {
					"MemorySizeInMB": memory,
					"MaxConcurrency": max_concurrency
				}
			}
		]
	)

# Create Endpoint
	ep_response = sm_client.create_endpoint(
		EndpointName=endpoint_name,
		EndpointConfigName=endpoint_config_name
	)

Wenn der serverlose Inferenzendpunkt ist InService, können wir den Endpunkt testen, indem wir eine Inferenzanforderung senden und die Vorhersagen beobachten. Das folgende Diagramm veranschaulicht die Architektur dieses Setups.

Beachten Sie, dass wir Rohdaten als Nutzlast an den Endpunkt senden können. Das von Autopilot generierte Ensemble-Modell integriert automatisch alle erforderlichen Feature-Transformations- und Inverse-Label-Transformationsschritte zusammen mit dem Algorithmusmodell und den Paketen in einem einzigen Modell.

Senden Sie eine Inferenzanfrage an das trainierte Modell

Verwenden Sie den folgenden Code, um Rückschlüsse auf Ihr Modell zu senden, das im Ensembling-Modus trainiert wurde:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer


payload = "34,blue-collar,married,basic.4y,no,no,no,telephone,may,tue,800,4,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0"

predictor = Predictor(
        endpoint_name=endpoint,
        sagmaker_session=session,
        serializer=CSVSerializer(),
    )

prediction = predictor.predict(payload).decode(‘utf-8’)
print(prediction)

Starten Sie einen Autopilot-Job im HPO-Modus

Im HPO-Modus, z CompletionCriteria, Außerdem MaxRuntimePerTrainingJobInSeconds und MaxAutoMLJobRuntimeInSeconds, wir könnten auch die angeben MaxCandidates um die Anzahl der Kandidaten zu begrenzen, die ein Autopilot-Job generiert. Beachten Sie, dass es sich hierbei um optionale Parameter handelt, die nur zur Begrenzung der Joblaufzeit zu Demonstrationszwecken festgelegt werden. Siehe folgenden Code:

training_mode = "HYPERPARAMETER_TUNING"

automl_job_config["Mode"] = training_mode
automl_job_config["CompletionCriteria"]["MaxCandidates"] = 15
hpo_automl_job_name =  f"{model_prefix}-HPO-{timestamp_suffix}"

response = sm_client.create_auto_ml_job(
					  AutoMLJobName=hpo_automl_job_name,
					  InputDataConfig=input_data_config,
					  OutputDataConfig=output_data_config,
					  AutoMLJobConfig=automl_job_config,
					  ProblemType=problem_type,
					  AutoMLJobObjective=automl_job_objective,
					  RoleArn=role,
					  Tags=tags_config
				)

Um die BestCandidate für den vorherigen Job können wir wieder die verwenden describe_automl_job Funktion:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_containers = job_response['BestCandidate']['InferenceContainers']
print(inference_containers)

Stellen Sie das trainierte Modell bereit

Autopilot im HPO-Modus für den Klassifizierungsproblemtyp generiert drei Inferenzcontainer.

Der erste Container behandelt die Schritte zur Merkmalstransformation. Als nächstes generiert der Algorithmus-Container die predicted_label mit der höchsten Wahrscheinlichkeit. Schließlich führt der Nachverarbeitungs-Inferenzcontainer eine inverse Transformation an dem vorhergesagten Etikett durch und bildet es auf das ursprüngliche Etikett ab. Weitere Informationen finden Sie unter Inferenzcontainerdefinitionen für Regressions- und Klassifizierungsproblemtypen.

Wir extrahieren diese drei Inferenzcontainer und stellen sie auf separaten serverlosen Endpunkten bereit. Für die Inferenz rufen wir die Endpunkte nacheinander auf, indem wir die Nutzlast zuerst an den Feature-Transform-Container senden, dann die Ausgabe von diesem Container an den Algorithmus-Container übergeben und schließlich die Ausgabe des vorherigen Inferenz-Containers an den Post-Processing-Container übergeben. die das vorhergesagte Etikett ausgibt.

Das folgende Diagramm veranschaulicht die Architektur dieses Setups.

Wir extrahieren die drei Inferenzcontainer aus der BestCandidate mit folgendem Code:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
inference_containers = job_response['BestCandidate']['InferenceContainers']

models = list()
endpoint_configs = list()
endpoints = list()

# For brevity, we've encapsulated create_model, create endpoint_config and create_endpoint as helper functions
for idx, container in enumerate(inference_containers):
    (status, model_arn) = create_autopilot_model(
								    sm_client,
								    automl_job_name,
            						role,
								    container,
								    idx)
    model_name = model_arn.split('/')[1]
    models.append(model_name)

    endpoint_config_name = f"epc-{model_name}"
    endpoint_name = f"ep-{model_name}"
    (status, epc_arn) = create_serverless_endpoint_config(
								    sm_client,
								    endpoint_config_name,
								    model_name,
            						memory=2048,
								    max_concurrency=10)
	endpoint_configs.append(endpoint_config_name)

	response = create_serverless_endpoint(
								    sm_client,
								    endpoint_name,
								    endpoint_config_name)
	endpoints.append(endpoint_name)

Senden Sie eine Inferenzanfrage an das trainierte Modell

Für die Schlussfolgerung senden wir die Nutzlast der Reihe nach: zuerst an den Feature-Transform-Container, dann an den Model-Container und schließlich an den Inverse-Label-Transformations-Container.

Siehe folgenden Code:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer

payload = "51,technician,married,professional.course,no,yes,no,cellular,apr,thu,687,1,0,1,success,-1.8,93.075,-47.1,1.365,5099.1"


for _, endpoint in enumerate(endpoints):
    try:
        print(f"payload: {payload}")
        predictor = Predictor(
            endpoint_name=endpoint,
            sagemaker_session=session,
            serializer=CSVSerializer(),
        )
        prediction = predictor.predict(payload)
        payload=prediction
    except Exception as e:
        print(f"Error invoking Endpoint; {endpoint} n {e}")
        break

Die vollständige Implementierung dieses Beispiels ist im folgenden jupyter verfügbar Notizbuch.

Aufräumen

Um Ressourcen zu bereinigen, können Sie die erstellten serverlosen Endpunkte, Endpunktkonfigurationen und Modelle löschen:

sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

for _, endpoint in enumerate(endpoints):
    try:
        sm_client.delete_endpoint(EndpointName=endpoint)
    except Exception as e:
        print(f"Exception:n{e}")
        continue
        
for _, endpoint_config in enumerate(endpoint_configs):
    try:
        sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

for _, autopilot_model in enumerate(models):
    try:
        sm_client.delete_model(ModelName=autopilot_model)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

Zusammenfassung

In diesem Beitrag haben wir gezeigt, wie wir von Autopilot generierte Modelle sowohl im Ensemble- als auch im HPO-Modus für serverlose Inferenzendpunkte bereitstellen können. Diese Lösung kann Ihre Fähigkeit beschleunigen, kosteneffiziente und vollständig verwaltete ML-Dienste wie Autopilot zu verwenden und zu nutzen, um Modelle schnell aus Rohdaten zu generieren und sie dann auf vollständig verwalteten serverlosen Inferenzendpunkten mit integrierter automatischer Skalierung bereitzustellen, um Kosten zu senken .

Wir empfehlen Ihnen, diese Lösung mit einem Datensatz auszuprobieren, der für Ihre Geschäfts-KPIs relevant ist. Sie können auf die in einem Jupyter-Notebook implementierte Lösung in der verweisen GitHub Repo.

Zusätzliche Referenzen

Über den Autor

Praveen Chamarthi ist Senior AI/ML Specialist bei Amazon Web Services. Er hat eine Leidenschaft für KI/ML und alles rund um AWS. Er hilft Kunden in ganz Amerika, ML-Workloads effizient auf AWS zu skalieren, zu innovieren und zu betreiben. In seiner Freizeit liest Praveen gerne und mag Science-Fiction-Filme.