Implementer Amazon SageMaker Autopilot-modeller til serverløse slutpunkter

Amazon SageMaker Autopilot bygger, træner og tuner automatisk de bedste maskinlæringsmodeller (ML) baseret på dine data, samtidig med at du kan bevare fuld kontrol og synlighed. Autopiloten kan også implementere trænede modeller til endepunkter i realtid automatisk.

Hvis du har arbejdsbelastninger med spidse eller uforudsigelige trafikmønstre, der kan tolerere koldstarter, ville det være mere omkostningseffektivt at implementere modellen til et serverløst slutpunkt.

Amazon SageMaker Serverless Inference er en specialbygget slutningsmulighed, der er ideel til arbejdsbelastninger med uforudsigelige trafikmønstre, og som kan tolerere koldstart. I modsætning til et slutpunkt i realtid, som understøttes af en langvarig beregningsinstans, leverer serverløse slutpunkter ressourcer efter behov med indbygget automatisk skalering. Serverløse slutpunkter skalerer automatisk baseret på antallet af indgående anmodninger og skalerer ressourcer ned til nul, når der ikke er nogen indgående anmodninger, hvilket hjælper dig med at minimere dine omkostninger.

I dette indlæg viser vi, hvordan man implementerer autopilottrænede modeller til serverløse slutningspunkter ved hjælp af Boto3 biblioteker forum Amazon SageMaker.

Autopilot træningstilstande

Før du opretter et autopiloteksperiment, kan du enten lade autopilot vælge træningstilstand automatisk, eller du kan vælge træningstilstand manuelt.

Autopilot understøtter i øjeblikket tre træningstilstande:

• Auto – Baseret på datasætstørrelsen vælger Autopilot automatisk enten ensembling eller HPO-tilstand. For datasæt større end 100 MB vælger Autopilot HPO; ellers vælger den ensembling.
• Ensembling – Autopiloten bruger AutoGluon ensembling teknik ved hjælp af model stabling og producerer en optimal prædiktiv model.
• Hyperparameter optimering (HPO) – Autopilot finder den bedste version af en model ved at tune hyperparametre ved hjælp af Bayesiansk optimering eller multi-fidelity-optimering, mens du kører træningsjob på dit datasæt. HPO-tilstand vælger de algoritmer, der er mest relevante for dit datasæt og vælger det bedste udvalg af hyperparametre til at tune dine modeller.

For at lære mere om autopilottræningstilstande, se Træningstilstande.

Løsningsoversigt

I dette indlæg bruger vi UCI Bank Marketing datasæt til at forudsige, om en kunde vil abonnere på et tidsindskud, der tilbydes af banken. Dette er en binær klassifikationsproblemtype.

Vi lancerer to autopilotjob ved hjælp af Boto3-biblioteker til SageMaker. Det første job bruger ensembling som den valgte træningstilstand. Vi implementerer derefter den enkelte ensemblemodel, der er genereret til et serverløst slutpunkt og sender inferensanmodninger til dette hostede slutpunkt.

Det andet job bruger HPO-træningstilstanden. For klassificeringsproblemtyper genererer Autopilot tre inferensbeholdere. Vi udtrækker disse tre inferensbeholdere og implementerer dem til separate serverløse slutpunkter. Derefter sender vi slutningsanmodninger til disse hostede slutpunkter.

For mere information om regressions- og klassifikationsproblemtyper, se Inferensbeholderdefinitioner for regressions- og klassifikationsproblemtyper.

Vi kan også starte autopilotjob fra Amazon SageMaker Studio UI. Hvis du starter job fra brugergrænsefladen, skal du sørge for at deaktivere Automatisk implementering valgmulighed i Implementering og avancerede indstillinger afsnit. Ellers vil Autopilot implementere den bedste kandidat til et slutpunkt i realtid.

Forudsætninger

Sørg for, at du har den seneste version af Boto3 og SageMaker Python-pakkerne installeret:

pip install -U boto3 sagemaker

Vi har brug for SageMaker-pakkeversionen >= 2.110.0 og Boto3 version >= boto3-1.24.84.

Start et autopilotjob med ensemblingstilstand

For at starte et autopilotjob ved hjælp af SageMaker Boto3-bibliotekerne bruger vi oprette_auto_ml_job API. Så går vi ind AutoMLJobConfig, InputDataConfigog AutoMLJobObjective som input til create_auto_ml_job. Se følgende kode:

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)

Autopilot returnerer BestCandidate modelobjekt, der har InferenceContainers påkrævet for at implementere modellerne til at slutte endepunkter. For at få BestCandidate til det foregående job bruger vi describe_automl_job fungere:

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)

Implementer den trænede model

Vi implementerer nu den foregående inferensbeholder til et serverløst slutpunkt. Det første trin er at oprette en model fra inferensbeholderen og derefter oprette en slutpunktskonfiguration, hvori vi angiver MemorySizeInMB , MaxConcurrency værdier for det serverløse slutpunkt sammen med modelnavnet. Til sidst opretter vi et slutpunkt med den ovenfor oprettede slutpunktskonfiguration.

Vi anbefaler at vælge din endepunktets hukommelsesstørrelse i henhold til din modelstørrelse. Hukommelsesstørrelsen skal være mindst lige så stor som din modelstørrelse. Dit serverløse slutpunkt har en minimum RAM-størrelse på 1024 MB (1 GB), og den maksimale RAM-størrelse, du kan vælge, er 6144 MB (6 GB).

De hukommelsesstørrelser, du kan vælge, er 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB eller 6144 MB.

For at hjælpe med at afgøre, om et serverløst slutpunkt er den rigtige implementeringsmulighed ud fra et omkostnings- og ydeevneperspektiv, opfordrer vi dig til at henvise til SageMaker Serverless Inference Benchmarking Toolkit, som tester forskellige slutpunktskonfigurationer og sammenligner den mest optimale med en sammenlignelig realtidshostinginstans.

Bemærk, at serverløse endepunkter kun accepterer SingleModel til slutningsbeholdere. Autopilot i ensembling-tilstand genererer en enkelt model, så vi kan implementere denne modelbeholder, som den er, til slutpunktet. Se følgende kode:

# 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
	)

Når det serverløse slutningspunkt er InService, kan vi teste slutpunktet ved at sende en slutningsanmodning og observere forudsigelserne. Følgende diagram illustrerer denne opsætnings arkitektur.

Bemærk, at vi kan sende rådata som en nyttelast til slutpunktet. Ensemblemodellen, der genereres af Autopilot, inkorporerer automatisk alle nødvendige funktionstransformations- og invers-labeltransformationstrin, sammen med algoritmemodellen og -pakkerne, i en enkelt model.

Send slutningsanmodning til den trænede model

Brug følgende kode til at sende slutninger om din model trænet i ensembling-tilstand:

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 et autopilotjob med HPO-tilstand

I HPO-tilstand, for CompletionCriteriaderudover MaxRuntimePerTrainingJobInSeconds , MaxAutoMLJobRuntimeInSeconds, vi kunne også specificere MaxCandidates for at begrænse antallet af kandidater, som et autopilotjob genererer. Bemærk, at disse er valgfrie parametre og kun er indstillet til at begrænse jobkørselstiden til demonstration. Se følgende kode:

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
				)

At hente BestCandidate til det foregående job, kan vi igen bruge describe_automl_job fungere:

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)

Implementer den trænede model

Autopilot i HPO-tilstand for klassificeringsproblemtypen genererer tre inferensbeholdere.

Den første beholder håndterer funktionstransformeringstrinene. Dernæst genererer algoritmebeholderen predicted_label med størst sandsynlighed. Til sidst udfører efterbehandlingsbeholderen en invers transformation på den forudsagte etiket og tilknytter den til den originale etiket. For mere information, se Inferensbeholderdefinitioner for regressions- og klassifikationsproblemtyper.

Vi uddrager disse tre inferensbeholdere og implementerer dem til et separat serverløst slutpunkt. For at slutninge påberåber vi endepunkterne i rækkefølge ved at sende nyttelasten først til feature-transform containeren, derefter sende output fra denne container til algoritme containeren og til sidst sende output fra den forrige inferens container til post-processing containeren, som udsender den forudsagte etiket.

Følgende diagram illustrerer denne opsætnings arkitektur.

Vi uddrager de tre inferensbeholdere fra BestCandidate med følgende kode:

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)

Send slutningsanmodning til den trænede model

For at konkludere, sender vi nyttelasten i rækkefølge: først til feature-transform containeren, derefter til model containeren og til sidst til invers label transformation containeren.

Se følgende kode:

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

Den fulde implementering af dette eksempel er tilgængelig i følgende jupyter notesbog.

Ryd op

For at rydde op i ressourcer kan du slette de oprettede serverløse endepunkter, endepunktskonfigurationer og modeller:

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

Konklusion

I dette indlæg viste vi, hvordan vi kan implementere autopilotgenererede modeller både i ensemble- og HPO-tilstande til serverløse inferensendepunkter. Denne løsning kan fremskynde din evne til at bruge og drage fordel af omkostningseffektive og fuldt administrerede ML-tjenester som Autopilot til at generere modeller hurtigt ud fra rå data og derefter implementere dem til fuldt administrerede serverløse slutpunkter med indbygget automatisk skalering for at reducere omkostningerne .

Vi opfordrer dig til at prøve denne løsning med et datasæt, der er relevant for din virksomheds KPI'er. Du kan henvise til løsningen implementeret i en Jupyter-notesbog i GitHub repo.

Yderligere referencer

Om forfatteren

Praveen Chamarthi er en senior AI/ML-specialist med Amazon Web Services. Han brænder for AI/ML og alt, hvad der har med AWS at gøre. Han hjælper kunder i hele Nord- og Sydamerika med at skalere, innovere og drive ML-arbejdsbelastninger effektivt på AWS. I sin fritid elsker Praveen at læse og nyder sci-fi-film.