Juurutage Amazon SageMaker Autopilot mudelid serverita järelduste lõpp-punktidesse

Amazon SageMakeri autopiloot koostab, treenib ja häälestab teie andmete põhjal automaatselt parimaid masinõppe (ML) mudeleid, võimaldades samal ajal säilitada täielikku kontrolli ja nähtavust. Autopiloot saab kasutada ka koolitatud mudeleid reaalajas järelduste lõpp-punktide jaoks automaatselt.

Kui teil on töökoormus teravate või ettearvamatute liiklusmustritega, mis taluvad külmkäivitust, oleks mudeli juurutamine serverita järelduste lõpp-punktis kuluefektiivsem.

Amazon SageMakeri serverita järeldus on sihipäraselt loodud järeldusvõimalus, mis sobib ideaalselt ettearvamatu liiklusmustriga töökoormuse jaoks ja talub külmkäivitust. Erinevalt reaalajas järelduse lõpp-punktist, mida toetab kaua töötav arvutusjuhtum, pakuvad serverita lõpp-punktid ressursse nõudmisel sisseehitatud automaatse skaleerimisega. Serverita lõpp-punktid skaleeruvad automaatselt sissetulevate päringute arvu põhjal ja vähendavad ressursse nullini, kui sissetulevaid päringuid pole, aidates teil kulusid minimeerida.

Selles postituses näitame, kuidas juurutada Autopiloodiga koolitatud mudeleid serverita järelduste lõpp-punktidesse, kasutades Boto3 teegid eest Amazon SageMaker.

Autopiloodi treeningrežiimid

Enne autopiloodi katse loomist saate lasta Autopiloodil treeningrežiimi automaatselt valida või valida treeningrežiimi käsitsi.

Autopiloot toetab praegu kolme treeningrežiimi:

• Auto – Andmestiku suuruse põhjal valib Autopilot automaatselt kas komplekteerimis- või HPO režiimi. Üle 100 MB suuruste andmekogumite puhul valib Autopilot HPO; vastasel juhul valib see komplekteerimise.
• Ansambeldamine – Autopiloot kasutab AutoGluon komplekteerimistehnikat, kasutades mudelite virnastamist ja loob optimaalse ennustava mudeli.
• Hüperparameetrite optimeerimine (HPO) – Autopiloot leiab mudeli parima versiooni, häälestades hüperparameetreid Bayesi optimeerimise või mitme täpsusega optimeerimise abil, samal ajal kui teie andmekogus treenitakse. HPO-režiim valib teie andmestiku jaoks kõige asjakohasemad algoritmid ja valib teie mudelite häälestamiseks parima valiku hüperparameetreid.

Autopiloodi treeningrežiimide kohta lisateabe saamiseks vaadake Treeningrežiimid.

Lahenduse ülevaade

Selles postituses kasutame UCI panga turundus andmekogum, et ennustada, kas klient liitub panga pakutava tähtajalise hoiusega. See on binaarse klassifikatsiooni probleemi tüüp.

Käivitame kaks Autopiloodi tööd, kasutades Boto3 teegid SageMakeri jaoks. Esimesel töökohal on valitud treeningrežiimiks komplekteerimine. Seejärel juurutame serverita lõpp-punkti genereeritud ühe ansambli mudeli ja saadame sellele hostitud lõpp-punktile järeldustaotlused.

Teine töö kasutab HPO koolitusrežiimi. Klassifitseerimisprobleemide tüüpide jaoks loob Autopilot kolm järelduskonteinerit. Eraldame need kolm järelduskonteinerit ja juurutame need serverita lõpp-punktidesse. Seejärel saadame nendele hostitud lõpp-punktidele järeldustaotlused.

Regressiooni- ja klassifitseerimisprobleemide tüüpide kohta lisateabe saamiseks vaadake Järelduskonteineri definitsioonid regressiooni- ja klassifitseerimisprobleemide tüüpide jaoks.

Samuti saame käivitada Autopiloodi töid Amazon SageMaker Studio UI. Kui käivitate töid kasutajaliidese kaudu, lülitage kindlasti välja Automaatne juurutamine valik Juurutamine ja täpsemad seaded osa. Vastasel juhul juurutab Autopilot parima kandidaadi reaalajas lõpp-punkti.

Eeldused

Veenduge, et teil oleks installitud Boto3 uusim versioon ja SageMaker Pythoni paketid:

pip install -U boto3 sagemaker

Vajame SageMakeri paketi versiooni >= 2.110.0 ja Boto3 versioon >= boto3-1.24.84.

Käivitage komplekteerimisrežiimiga autopiloodi töö

Autopiloodi töö käivitamiseks SageMaker Boto3 teekide abil kasutame loo_auto_ml_job API. Siis astume sisse AutoMLJobConfig, InputDataConfigja AutoMLJobObjective sisenditena create_auto_ml_job. Vaadake järgmist koodi:

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)

Autopiloot tagastab BestCandidate mudelobjekt, millel on InferenceContainers vajalik mudelite juurutamiseks lõpp-punktide tuletamiseks. Et saada BestCandidate eelmise töö jaoks kasutame describe_automl_job funktsioon:

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)

Rakendage koolitatud mudel

Nüüd juurutame eelmise järelduskonteineri serverita lõpp-punkti. Esimene samm on luua järelduskonteinerist mudel, seejärel luua lõpp-punkti konfiguratsioon, milles määrame MemorySizeInMB ja MaxConcurrency serverita lõpp-punkti väärtused koos mudeli nimega. Lõpuks loome ülaltoodud lõpp-punkti konfiguratsiooniga lõpp-punkti.

Soovitame valida oma lõpp-punkti mälumaht vastavalt teie mudeli suurusele. Mälu maht peaks olema vähemalt sama suur kui teie mudeli suurus. Teie serverita lõpp-punkti minimaalne RAM-i suurus on 1024 MB (1 GB) ja maksimaalne RAM-i suurus, mille saate valida, on 6144 MB (6 GB).

Mälu suurused, mida saate valida, on 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB või 6144 MB.

Et aidata kindlaks teha, kas serverita lõpp-punkt on kulude ja jõudluse seisukohast õige juurutusvalik, soovitame teil tutvuda SageMaker Serverless Inference Benchmarking Toolkit, mis testib erinevaid lõpp-punkti konfiguratsioone ja võrdleb optimaalseimat võrreldava reaalajas hostimise eksemplariga.

Pange tähele, et serverita lõpp-punktid aktsepteerivad ainult SingleModel järelduskonteinerite jaoks. Koostamisrežiimis olev autopiloot loob ühe mudeli, nii et saame selle mudeli konteineri lõpp-punktis juurutada. Vaadake järgmist koodi:

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

Kui serverita järelduse lõpp-punkt on InService, saame lõpp-punkti testida, saates järelduspäringu ja jälgida ennustusi. Järgmine diagramm illustreerib selle seadistuse arhitektuuri.

Pange tähele, et saame algandmeid lõpp-punkti kasuliku koormana saata. Autopiloodi loodud ansamblimudel sisaldab automaatselt kõik vajalikud funktsioonide teisendamise ja pöördmärgistuse teisendamise sammud koos algoritmimudeli ja pakettidega ühte mudelisse.

Saada koolitatud mudelile järeldustaotlus

Kasutage järgmist koodi, et saata järeldused oma komplekteerimisrežiimis treenitud mudeli kohta:

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)

Käivitage autopiloodi töö HPO režiimiga

HPO režiimis, jaoks CompletionCriteria, Pealegi MaxRuntimePerTrainingJobInSeconds ja MaxAutoMLJobRuntimeInSeconds, võiksime ka täpsustada MaxCandidates Autopiloodi töö genereeritavate kandidaatide arvu piiramiseks. Pange tähele, et need on valikulised parameetrid ja need on seatud vaid demonstreerimiseks töö tööaja piiramiseks. Vaadake järgmist koodi:

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
				)

Et saada BestCandidate eelmise töö jaoks saame jälle kasutada describe_automl_job funktsioon:

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)

Rakendage koolitatud mudel

Autopiloot HPO-režiimis klassifikatsiooniprobleemi tüübi jaoks loob kolm järelduskonteinerit.

Esimene konteiner käsitleb funktsioonide teisendamise etappe. Järgmisena genereerib algoritmi konteiner predicted_label suurima tõenäosusega. Lõpuks teostab järeltöötluse järelduskonteiner ennustatud sildil pöördteisenduse ja vastendab selle algse sildiga. Lisateabe saamiseks vaadake Järelduskonteineri definitsioonid regressiooni- ja klassifitseerimisprobleemide tüüpide jaoks.

Eraldame need kolm järelduskonteinerit ja juurutame need eraldi serverita lõpp-punktidesse. Järelduste tegemiseks kutsume välja lõpp-punktid järjestikku, saates kasuliku koormuse esmalt funktsioonide teisendamise konteinerisse, seejärel edastades selle konteineri väljundi algoritmi konteinerisse ja lõpuks edastades eelmise järelduskonteineri väljundi järeltöötluskonteinerisse, mis väljastab ennustatud sildi.

Järgmine diagramm illustreerib selle seadistuse arhitektuuri.

Eraldame kolm järelduskonteinerit BestCandidate järgmise koodiga:

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)

Saada koolitatud mudelile järeldustaotlus

Järelduste tegemiseks saadame kasuliku koormuse järjestikku: esmalt tunnuste teisenduse konteinerisse, seejärel mudelkonteinerisse ja lõpuks pöördsildiga teisenduskonteinerisse.

Vaadake järgmist koodi:

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

Selle näite täielik teostus on saadaval järgmises jupyteris märkmik.

Koristage

Ressursside puhastamiseks saate kustutada loodud serverita lõpp-punktid, lõpp-punkti konfiguratsioonid ja mudelid.

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

Järeldus

Selles postituses näitasime, kuidas saame juurutada Autopiloodi loodud mudeleid nii ansambli- kui ka HPO režiimides serverita järelduste lõpp-punktidesse. See lahendus võib kiirendada kulutõhusate ja täielikult hallatavate ML-teenuste (nt Autopilot) kasutamist ja ärakasutamist, et luua toorandmetest kiiresti mudeleid ja seejärel juurutada need täielikult hallatud serverita järeldusotspunktidesse koos sisseehitatud automaatse skaleerimisega, et vähendada kulusid. .

Soovitame teil proovida seda lahendust teie ettevõtte KPI-de jaoks asjakohase andmekogumiga. Jupyteri sülearvutis rakendatud lahendust saate vaadata jaotises GitHub repo.

Täiendavad viited

Teave Autor

Praveen Chamarthi on Amazoni veebiteenuste AI/ML vanemspetsialist. Ta on kirglik AI/ML-i ja kõigi asjade AWS-i vastu. Ta aitab klientidel üle Ameerika ML-töökoormust AWS-is tõhusalt skaleerida, uuendada ja hallata. Vabal ajal armastab Praveen lugeda ja naudib ulmefilme.