Implementeer Amazon SageMaker Autopilot-modellen op serverloze inferentie-eindpunten

Amazon SageMaker-stuurautomaat bouwt, traint en stemt automatisch de beste machine learning (ML)-modellen af ​​op basis van uw gegevens, terwijl u volledige controle en zichtbaarheid behoudt. Autopilot kan ook automatisch getrainde modellen inzetten voor real-time inferentie-eindpunten.

Als u workloads hebt met piekerige of onvoorspelbare verkeerspatronen die koude starts kunnen verdragen, dan zou het kostenefficiënter zijn om het model te implementeren op een serverloos inferentie-eindpunt.

Amazon SageMaker Serverloze inferentie is een speciaal gebouwde inferentieoptie die ideaal is voor workloads met onvoorspelbare verkeerspatronen en die koude starts kan verdragen. In tegenstelling tot een real-time inferentie-eindpunt, dat wordt ondersteund door een langlopende rekeninstantie, leveren serverloze eindpunten bronnen op aanvraag met ingebouwde automatische schaling. Serverloze endpoints worden automatisch geschaald op basis van het aantal binnenkomende verzoeken en schalen resources terug naar nul wanneer er geen binnenkomende verzoeken zijn, waardoor u uw kosten kunt minimaliseren.

In dit bericht laten we zien hoe u door Autopilot getrainde modellen implementeert op serverloze inferentie-eindpunten met behulp van de Boto3-bibliotheken For Amazon Sage Maker.

Trainingsmodi voor automatische piloot

Voordat u een Autopilot-experiment maakt, kunt u Autopilot de trainingsmodus automatisch laten selecteren of u kunt de trainingsmodus handmatig selecteren.

Autopilot ondersteunt momenteel drie trainingsmodi:

• automobiel – Op basis van de grootte van de dataset kiest Autopilot automatisch voor de combinatie- of HPO-modus. Voor datasets groter dan 100 MB kiest Autopilot voor HPO; anders kiest het voor verenigen.
• Ensembleren – Autopilot maakt gebruik van de AutoGluon assembleertechniek met behulp van modelstapeling en produceert een optimaal voorspellend model.
• Hyperparameter optimalisatie (HPO) - Autopilot vindt de beste versie van een model door hyperparameters af te stemmen met behulp van Bayesiaanse optimalisatie of multi-fidelity-optimalisatie terwijl trainingstaken worden uitgevoerd op uw dataset. HPO-modus selecteert de algoritmen die het meest relevant zijn voor uw dataset en selecteert de beste reeks hyperparameters om uw modellen af ​​te stemmen.

Raadpleeg voor meer informatie over de trainingsmodi van de stuurautomaat Trainingsmodi.

Overzicht oplossingen

In dit bericht gebruiken we de UCI Bank-marketing dataset om te voorspellen of een klant zal intekenen op een termijndeposito aangeboden door de bank. Dit is een probleemtype met binaire classificatie.

We starten twee Autopilot-taken met behulp van de Boto3-bibliotheken voor SageMaker. De eerste taak gebruikt ensemblen als de gekozen trainingsmodus. Vervolgens implementeren we het enkele ensemblemodel dat is gegenereerd op een serverloos eindpunt en sturen we gevolgtrekkingsverzoeken naar dit gehoste eindpunt.

De tweede taak maakt gebruik van de HPO-trainingsmodus. Voor typen classificatieproblemen genereert Autopilot drie inferentiecontainers. We extraheren deze drie inferentiecontainers en implementeren ze om serverloze eindpunten te scheiden. Vervolgens sturen we deductieverzoeken naar deze gehoste eindpunten.

Voor meer informatie over regressie- en classificatieprobleemtypen, zie Inferentiecontainerdefinities voor typen regressie- en classificatieproblemen.

We kunnen ook Autopilot-taken starten vanuit de Amazon SageMaker Studio gebruikersinterface. Als u taken vanuit de gebruikersinterface start, zorg er dan voor dat u de Automatisch implementeren optie in het Implementatie en geavanceerde instellingen sectie. Anders zet Autopilot de beste kandidaat in op een real-time eindpunt.

Voorwaarden

Zorg ervoor dat u de nieuwste versie van Boto3 en de SageMaker Python-pakketten hebt geïnstalleerd:

pip install -U boto3 sagemaker

We hebben de SageMaker-pakketversie nodig >= 2.110.0 en Boto3-versie >= boto3-1.24.84.

Start een Autopilot-taak met ensemblemodus

Om een ​​Autopilot-taak te starten met behulp van de SageMaker Boto3-bibliotheken, gebruiken we de create_auto_ml_job API. Wij gaan dan naar binnen AutoMLJobConfig, InputDataConfig en AutoMLJobObjective als input voor de create_auto_ml_job. Zie de volgende 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)

De automatische piloot retourneert het BestCandidate modelobject met de InferenceContainers vereist om de modellen in te zetten om eindpunten af ​​te leiden. Om de BestCandidate voor de vorige taak gebruiken we de describe_automl_job functie:

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)

Implementeer het getrainde model

We implementeren nu de voorgaande inferentiecontainer op een serverloos eindpunt. De eerste stap is het maken van een model van de inferentiecontainer en vervolgens een eindpuntconfiguratie maken waarin we de MemorySizeInMB en MaxConcurrency waarden voor het serverloze eindpunt samen met de modelnaam. Ten slotte maken we een eindpunt met de hierboven gemaakte eindpuntconfiguratie.

We raden aan om uw te kiezen geheugengrootte van het eindpunt volgens uw modelgrootte. De geheugengrootte moet minstens zo groot zijn als de grootte van uw model. Uw serverloze eindpunt heeft een minimale RAM-grootte van 1024 MB (1 GB) en de maximale RAM-grootte die u kunt kiezen is 6144 MB (6 GB).

De geheugengroottes die u kunt kiezen zijn 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB of 6144 MB.

Om te helpen bepalen of een serverloos eindpunt de juiste implementatieoptie is vanuit een kosten- en prestatieperspectief, raden we u aan om de SageMaker Serverless Inferentie Benchmarking Toolkit, die verschillende eindpuntconfiguraties test en de meest optimale vergelijkt met een vergelijkbare realtime hostinginstantie.

Houd er rekening mee dat serverloze eindpunten alleen accepteren SingleModel voor inferentiecontainers. Autopilot in de montagemodus genereert een enkel model, dus we kunnen deze modelcontainer zoals het is inzetten op het eindpunt. Zie de volgende 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
	)

Wanneer het serverloze inferentie-eindpunt is InService, kunnen we het eindpunt testen door een deductieverzoek te verzenden en de voorspellingen te observeren. Het volgende diagram illustreert de architectuur van deze opstelling.

Merk op dat we onbewerkte gegevens als een payload naar het eindpunt kunnen sturen. Het ensemblemodel dat door Autopilot wordt gegenereerd, bevat automatisch alle vereiste stappen voor kenmerktransformatie en inverse labeltransformatie, samen met het algoritmemodel en de pakketten, in één enkel model.

Stuur een verzoek tot gevolgtrekking naar het getrainde model

Gebruik de volgende code om gevolgtrekkingen te verzenden naar uw model dat is getraind met behulp van de ensemblemodus:

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)

Start een Autopilot Job met HPO-modus

In HPO-modus, voor CompletionCriteriatrouwens MaxRuntimePerTrainingJobInSeconds en MaxAutoMLJobRuntimeInSeconds, we kunnen ook de specificeren MaxCandidates om het aantal kandidaten te beperken dat een Autopilot-taak zal genereren. Merk op dat dit optionele parameters zijn en alleen zijn ingesteld om de uitvoeringstijd van de taak voor demonstratie te beperken. Zie de volgende 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
				)

Om het te krijgen BestCandidate voor de vorige taak kunnen we opnieuw de gebruiken describe_automl_job functie:

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)

Implementeer het getrainde model

Autopilot in HPO-modus voor het type classificatieprobleem genereert drie inferentiecontainers.

De eerste container verwerkt de feature-transformatie stappen. Vervolgens genereert de algoritmecontainer de predicted_label met de grootste waarschijnlijkheid. Ten slotte voert de inferentiecontainer na verwerking een inverse transformatie uit op het voorspelde label en wijst het toe aan het oorspronkelijke label. Voor meer informatie, zie Inferentiecontainerdefinities voor typen regressie- en classificatieproblemen.

We extraheren deze drie inferentiecontainers en implementeren ze op afzonderlijke serverloze eindpunten. Voor gevolgtrekking roepen we de eindpunten op volgorde aan door de payload eerst naar de feature-transform-container te sturen, vervolgens de uitvoer van deze container door te geven aan de algoritmecontainer en ten slotte de uitvoer van de vorige inferentiecontainer door te geven aan de naverwerkingscontainer. die het voorspelde label uitvoert.

Het volgende diagram illustreert de architectuur van deze opstelling.

We halen de drie inferentiecontainers uit de BestCandidate met de volgende 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)

Stuur een verzoek tot gevolgtrekking naar het getrainde model

Ter afleiding sturen we de payload achtereenvolgens: eerst naar de feature-transform-container, vervolgens naar de model-container en ten slotte naar de inverse-label-transformatie-container.

Zie de volgende 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

De volledige implementatie van dit voorbeeld is beschikbaar in de volgende jupyter notitieboekje.

Opruimen

Om bronnen op te schonen, kunt u de gemaakte serverloze eindpunten, eindpuntconfiguraties en modellen verwijderen:

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

Conclusie

In dit bericht hebben we laten zien hoe we door Autopilot gegenereerde modellen zowel in ensemble- als in HPO-modus kunnen inzetten op serverloze inferentie-eindpunten. Deze oplossing kan uw mogelijkheden versnellen om kostenefficiënte en volledig beheerde ML-services zoals Autopilot te gebruiken om snel modellen te genereren op basis van onbewerkte gegevens en deze vervolgens te implementeren op volledig beheerde serverloze inferentie-eindpunten met ingebouwde automatische schaling om kosten te verlagen .

We raden u aan deze oplossing te proberen met een dataset die relevant is voor uw zakelijke KPI's. U kunt verwijzen naar de oplossing die is geïmplementeerd in een Jupyter-notebook in de GitHub repo.

Aanvullende referenties

Over de auteur

Praveen Chamarthi is een Senior AI/ML-specialist bij Amazon Web Services. Hij is gepassioneerd door AI/ML en alles wat met AWS te maken heeft. Hij helpt klanten in heel Amerika om ML-workloads efficiënt op AWS te schalen, te innoveren en uit te voeren. In zijn vrije tijd houdt Praveen van lezen en geniet hij van sciencefictionfilms.