Distribuera Amazon SageMaker Autopilot-modeller till serverlösa slutpunkter

Amazon SageMaker autopilot bygger, tränar och justerar automatiskt de bästa maskininlärningsmodellerna (ML) baserat på dina data, samtidigt som du kan behålla full kontroll och synlighet. Autopiloten kan också distribuera utbildade modeller för slutpunkter i realtid automatiskt.

Om du har arbetsbelastningar med taggiga eller oförutsägbara trafikmönster som kan tolerera kallstarter, skulle det vara mer kostnadseffektivt att distribuera modellen till en serverlös slutpunkt.

Amazon SageMaker Serverless Inference är ett specialbyggt slutledningsalternativ som är idealiskt för arbetsbelastningar med oförutsägbara trafikmönster och som kan tolerera kallstarter. Till skillnad från en slutpunkt i realtid, som stöds av en långvarig beräkningsinstans, tillhandahåller serverlösa slutpunkter resurser på begäran med inbyggd automatisk skalning. Serverlösa slutpunkter skalar automatiskt baserat på antalet inkommande förfrågningar och skalar ner resurser till noll när det inte finns några inkommande förfrågningar, vilket hjälper dig att minimera dina kostnader.

I det här inlägget visar vi hur man distribuerar autopilottränade modeller till serverlösa slutpunkter med hjälp av Boto3 bibliotek för Amazon SageMaker.

Autopilotträningslägen

Innan du skapar ett autopilotexperiment kan du antingen låta autopilot välja träningsläge automatiskt eller så kan du välja träningsläge manuellt.

Autopiloten stöder för närvarande tre träningslägen:

• Bil – Baserat på datauppsättningsstorlek väljer Autopilot automatiskt antingen ensembling eller HPO-läge. För datauppsättningar större än 100 MB väljer Autopilot HPO; annars väljer den ensembling.
• Montering – Autopiloten använder AutoGluon ensemblingsteknik med modellstapling och producerar en optimal prediktiv modell.
• Hyperparameteroptimering (HPO) – Autopiloten hittar den bästa versionen av en modell genom att ställa in hyperparametrar med Bayesiansk optimering eller multifidelity-optimering medan du kör träningsjobb på din datauppsättning. HPO-läget väljer de algoritmer som är mest relevanta för din datauppsättning och väljer det bästa intervallet av hyperparametrar för att ställa in dina modeller.

För att lära dig mer om autopilotträningslägen, se Träningslägen.

Lösningsöversikt

I det här inlägget använder vi UCI Bank Marketing datauppsättning för att förutsäga om en kund kommer att prenumerera på en tidsinsättning som erbjuds av banken. Detta är en binär klassificeringsproblemtyp.

Vi lanserar två autopilotjobb med hjälp av Boto3-bibliotek för SageMaker. Det första jobbet använder ensembling som valt träningsläge. Vi distribuerar sedan den enda ensemblemodellen som genereras till en serverlös slutpunkt och skickar slutledningsbegäranden till denna värdslutpunkt.

Det andra jobbet använder HPO-träningsläget. För klassificeringsproblemtyper genererar Autopilot tre slutledningsbehållare. Vi extraherar dessa tre slutledningsbehållare och distribuerar dem till separata serverlösa slutpunkter. Sedan skickar vi inferensförfrågningar till dessa värdslutpunkter.

För mer information om regressions- och klassificeringsproblemtyper, se Definitioner av slutledningsbehållare för regressions- och klassificeringsproblemtyper.

Vi kan också lansera Autopilot-jobb från Amazon SageMaker Studio UI. Om du startar jobb från användargränssnittet, se till att stänga av Automatisk distribution alternativet i Implementering och avancerade inställningar sektion. Annars kommer autopiloten att distribuera den bästa kandidaten till en realtidsslutpunkt.

Förutsättningar

Se till att du har den senaste versionen av Boto3 och SageMaker Python-paketen installerade:

pip install -U boto3 sagemaker

Vi behöver SageMaker-paketversionen >= 2.110.0 och Boto3-versionen >= boto3-1.24.84.

Starta ett autopilotjobb med ensemblingsläge

För att starta ett autopilotjobb med SageMaker Boto3-biblioteken använder vi create_auto_ml_job API. Vi passerar sedan in AutoMLJobConfig, InputDataConfigoch AutoMLJobObjective som input till create_auto_ml_job. Se följande kod:

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)

Autopiloten returnerar BestCandidate modellobjekt som har InferenceContainers krävs för att distribuera modellerna för att sluta slutpunkter. För att få BestCandidate för det föregående jobbet använder vi describe_automl_job fungera:

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)

Distribuera den utbildade modellen

Vi distribuerar nu den föregående slutledningsbehållaren till en serverlös slutpunkt. Det första steget är att skapa en modell från slutledningsbehållaren och sedan skapa en slutpunktskonfiguration där vi specificerar MemorySizeInMB och MaxConcurrency värden för den serverlösa slutpunkten tillsammans med modellnamnet. Slutligen skapar vi en slutpunkt med den slutpunktskonfiguration som skapats ovan.

Vi rekommenderar att du väljer din slutpunktens minnesstorlek enligt din modellstorlek. Minnesstorleken bör vara minst lika stor som din modellstorlek. Din serverlösa slutpunkt har en minsta RAM-storlek på 1024 MB (1 GB), och den maximala RAM-storlek du kan välja är 6144 MB (6 GB).

Minnesstorlekarna du kan välja är 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB eller 6144 MB.

För att hjälpa dig att avgöra om en serverlös slutpunkt är rätt distributionsalternativ ur ett kostnads- och prestandaperspektiv, rekommenderar vi att du hänvisar till SageMaker Serverless Inference Benchmarking Toolkit, som testar olika slutpunktskonfigurationer och jämför den mest optimala med en jämförbar realtidsvärdinstans.

Observera att serverlösa slutpunkter endast accepterar SingleModel för slutledningsbehållare. Autopilot i ensemblingsläge genererar en enda modell, så vi kan distribuera denna modellbehållare som den är till slutpunkten. Se följande kod:

# 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 den serverlösa slutpunkten är InService, kan vi testa slutpunkten genom att skicka en inferensförfrågan och observera förutsägelserna. Följande diagram illustrerar arkitekturen för denna installation.

Observera att vi kan skicka rådata som en nyttolast till slutpunkten. Ensemblemodellen som genereras av Autopilot innehåller automatiskt alla nödvändiga funktionstransformerings- och invers-etiketttransformationssteg, tillsammans med algoritmmodellen och paketen, till en enda modell.

Skicka inferensförfrågan till den utbildade modellen

Använd följande kod för att skicka slutsatser om din modell tränad i ensemblingsläge:

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)

Starta ett autopilotjobb med HPO-läge

I HPO-läge, för CompletionCriteria, Förutom MaxRuntimePerTrainingJobInSeconds och MaxAutoMLJobRuntimeInSeconds, vi kan också specificera MaxCandidates för att begränsa antalet kandidater som ett autopilotjobb genererar. Observera att dessa är valfria parametrar och endast är inställda för att begränsa jobbets körtid för demonstration. Se följande kod:

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
				)

För att få den BestCandidate för det föregående jobbet kan vi återigen använda describe_automl_job fungera:

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)

Distribuera den utbildade modellen

Autopilot i HPO-läge för klassificeringsproblemtypen genererar tre slutledningsbehållare.

Den första behållaren hanterar funktionsomvandlingsstegen. Därefter genererar algoritmbehållaren predicted_label med störst sannolikhet. Slutligen utför efterbearbetningsinferensbehållaren en omvänd transformation på den förutsagda etiketten och mappar den till den ursprungliga etiketten. För mer information, se Definitioner av slutledningsbehållare för regressions- och klassificeringsproblemtyper.

Vi extraherar dessa tre slutledningsbehållare och distribuerar dem till separata serverlösa slutpunkter. Som slutledning anropar vi ändpunkterna i sekvens genom att skicka nyttolasten först till funktionstransformeringsbehållaren, sedan skicka utdata från denna behållare till algoritmbehållaren och slutligen skicka utdata från den föregående slutledningsbehållaren till efterbearbetningsbehållaren, som matar ut den förutsagda etiketten.

Följande diagram illustrerar arkitekturen för denna installation.

Vi extraherar de tre slutledningsbehållarna från BestCandidate med följande kod:

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)

Skicka inferensförfrågan till den utbildade modellen

Som slutledning skickar vi nyttolasten i ordningsföljd: först till egenskapstransformeringsbehållaren, sedan till modellbehållaren och slutligen till transformationsbehållaren för omvänd etikett.

Se följande kod:

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 fullständiga implementeringen av detta exempel är tillgänglig i följande jupyter anteckningsbok.

Städa upp

För att rensa resurser kan du ta bort de skapade serverlösa slutpunkterna, slutpunktskonfigurationerna och modellerna:

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

Slutsats

I det här inlägget visade vi hur vi kan distribuera autopilotgenererade modeller både i ensemble- och HPO-lägen till serverlösa slutpunkter. Denna lösning kan påskynda din förmåga att använda och dra fördel av kostnadseffektiva och helt hanterade ML-tjänster som Autopilot för att snabbt generera modeller från rådata och sedan distribuera dem till helt hanterade serverlösa slutpunkter med inbyggd automatisk skalning för att minska kostnaderna .

Vi uppmuntrar dig att prova den här lösningen med en datauppsättning som är relevant för ditt företags KPI:er. Du kan referera till lösningen implementerad i en Jupyter-anteckningsbok i GitHub repo.

Ytterligare referenser

Om författaren

Praveen Chamarthi är senior AI/ML-specialist med Amazon Web Services. Han brinner för AI/ML och allt som rör AWS. Han hjälper kunder över hela Amerika att skala, förnya och driva ML-arbetsbelastningar effektivt på AWS. På fritiden älskar Praveen att läsa och tycker om sci-fi-filmer.