Razmestite modele Amazon SageMaker Autopilot na končne točke sklepanja brez strežnika

Amazonski SageMaker avtopilot samodejno gradi, usposablja in prilagaja najboljše modele strojnega učenja (ML) na podlagi vaših podatkov, hkrati pa vam omogoča, da ohranite popoln nadzor in vidljivost. Avtopilot lahko tudi samodejno uvede usposobljene modele na končne točke sklepanja v realnem času.

Če imate delovne obremenitve s kočljivimi ali nepredvidljivimi prometnimi vzorci, ki lahko dopuščajo hladne zagone, bi bila uvedba modela na končno točko sklepanja brez strežnika stroškovno učinkovitejša.

Sklep brez strežnika Amazon SageMaker je namensko izdelana možnost sklepanja, idealna za delovne obremenitve z nepredvidljivimi prometnimi vzorci in ki lahko prenašajo hladne zagone. Za razliko od končne točke sklepanja v realnem času, ki je podprta z dolgo delujočo računalniško instanco, končne točke brez strežnika zagotavljajo vire na zahtevo z vgrajenim samodejnim skaliranjem. Brezstrežniške končne točke se samodejno prilagajajo glede na število dohodnih zahtev in zmanjšajo vire na nič, ko ni dohodnih zahtev, kar vam pomaga zmanjšati stroške.

V tej objavi prikazujemo, kako uvesti modele, usposobljene za avtopilot, na končne točke sklepanja brez strežnika z uporabo Knjižnice Boto3 za Amazon SageMaker.

Načini usposabljanja za avtopilota

Preden ustvarite poskus z avtopilotom, lahko pustite, da avtopilot samodejno izbere način vadbe ali pa način vadbe izberete ročno.

Avtopilot trenutno podpira tri načine usposabljanja:

• Auto – Na podlagi velikosti nabora podatkov avtopilot samodejno izbere način združevanja ali HPO. Za nabore podatkov, večje od 100 MB, avtopilot izbere HPO; sicer pa izbere ansambel.
• Sestavljanje – Avtopilot uporablja AutoGluon tehniko združevanja z zlaganjem modelov in izdela optimalen napovedni model.
• Optimizacija hiperparametrov (HPO) – Avtopilot poišče najboljšo različico modela s prilagoditvijo hiperparametrov z uporabo Bayesove optimizacije ali optimizacije z več zvestobami med izvajanjem izobraževalnih opravil na vašem naboru podatkov. Način HPO izbere algoritme, ki so najbolj ustrezni za vaš nabor podatkov, in izbere najboljši obseg hiperparametrov za nastavitev vaših modelov.

Če želite izvedeti več o načinih usposabljanja avtopilota, glejte Načini usposabljanja.

Pregled rešitev

V tej objavi uporabljamo UCI Bank Marketing nabor podatkov za napovedovanje, ali bo stranka vpisala vezani depozit, ki ga ponuja banka. To je tip problema binarne klasifikacije.

Zaženemo dve nalogi avtopilota z uporabo Knjižnice Boto3 za SageMaker. Prva naloga uporablja sestavljanje kot izbrani način usposabljanja. Nato razmestimo enotni model ansambla, ustvarjen na končni točki brez strežnika, in tej gostujoči končni točki pošljemo zahteve za sklepanje.

Drugo opravilo uporablja način usposabljanja HPO. Za tipe problemov klasifikacije Autopilot ustvari tri vsebnike sklepanja. Izvlečemo te tri sklepne vsebnike in jih razmestimo v ločene brezstrežniške končne točke. Nato tem gostujočim končnim točkam pošljemo zahteve za sklepanje.

Za več informacij o vrstah problemov regresije in klasifikacije glejte Definicije vsebnika sklepanja za tipe problemov regresije in klasifikacije.

Opravila za avtopilot lahko zaženemo tudi iz Amazon SageMaker Studio uporabniški vmesnik. Če zaženete opravila iz uporabniškega vmesnika, se prepričajte, da ste izklopili Samodejno uvajanje možnost v Uvajanje in napredne nastavitve razdelek. V nasprotnem primeru bo avtopilot uvedel najboljšega kandidata na končno točko v realnem času.

Predpogoji

Prepričajte se, da imate nameščeno najnovejšo različico Boto3 in paketov SageMaker Python:

pip install -U boto3 sagemaker

Potrebujemo različico paketa SageMaker >= 2.110.0 in različico Boto3 >= boto3-1.24.84.

Zaženite opravilo avtopilota z načinom združevanja

Za zagon opravila avtopilota z uporabo knjižnic SageMaker Boto3 uporabljamo create_auto_ml_job API. Nato vstopimo AutoMLJobConfig, InputDataConfigin AutoMLJobObjective kot vložke v create_auto_ml_job. Glej naslednjo kodo:

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)

Avtopilot vrne BestCandidate model predmeta, ki ima InferenceContainers potreben za uvajanje modelov v končne točke sklepanja. Da bi dobili BestCandidate za prejšnje delo uporabljamo describe_automl_job funkcija:

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)

Razmestite usposobljeni model

Zdaj razmestimo prejšnji vsebnik sklepanja na končno točko brez strežnika. Prvi korak je ustvariti model iz vsebnika sklepanja, nato pa ustvariti konfiguracijo končne točke, v kateri podamo MemorySizeInMB in MaxConcurrency vrednosti za končno točko brez strežnika skupaj z imenom modela. Končno ustvarimo končno točko z zgoraj ustvarjeno konfiguracijo končne točke.

Priporočamo, da izberete svojega velikost pomnilnika končne točke glede na velikost vašega modela. Velikost pomnilnika mora biti vsaj tako velika kot velikost vašega modela. Vaša končna točka brez strežnika ima najmanjšo velikost RAM-a 1024 MB (1 GB), največja velikost RAM-a, ki jo lahko izberete, pa je 6144 MB (6 GB).

Izbirate lahko med velikostmi pomnilnika 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB ali 6144 MB.

Da bi lažje ugotovili, ali je brezstrežniška končna točka prava možnost uvedbe z vidika stroškov in zmogljivosti, vam priporočamo, da si ogledate Komplet orodij za primerjalno analizo brezstrežniškega sklepanja SageMaker, ki preizkuša različne konfiguracije končne točke in primerja najbolj optimalno s primerljivo instanco gostovanja v realnem času.

Upoštevajte, da brezstrežniške končne točke sprejemajo samo SingleModel za posode za sklepanje. Avtopilot v načinu združevanja generira en sam model, tako da lahko ta vsebnik modela razmestimo, kot je, do končne točke. Oglejte si naslednjo kodo:

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

Ko je končna točka sklepanja brez strežnika InService, lahko preizkusimo končno točko tako, da pošljemo zahtevo za sklepanje in opazujemo napovedi. Naslednji diagram ponazarja arhitekturo te nastavitve.

Upoštevajte, da lahko pošljemo neobdelane podatke kot tovor na končno točko. Ansambelski model, ki ga generira Autopilot, samodejno združuje vse zahtevane korake pretvorbe funkcij in inverzne oznake, skupaj z modelom algoritma in paketi, v en sam model.

Pošljite zahtevo za sklepanje usposobljenemu modelu

Uporabite naslednjo kodo za pošiljanje sklepanja o vašem modelu, ki je usposobljen z uporabo načina združevanja:

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)

Zaženite opravilo avtopilota z načinom HPO

V načinu HPO, za CompletionCriteria, poleg tega MaxRuntimePerTrainingJobInSeconds in MaxAutoMLJobRuntimeInSeconds, lahko tudi določimo MaxCandidates da omejite število kandidatov, ki jih bo ustvarilo delovno mesto avtopilota. Upoštevajte, da so to neobvezni parametri in so nastavljeni samo za omejitev časa izvajanja opravila za predstavitev. Oglejte si naslednjo kodo:

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
				)

Da bi dobili BestCandidate za prejšnje delo lahko ponovno uporabimo describe_automl_job funkcija:

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)

Razmestite usposobljeni model

Avtopilot v načinu HPO za vrsto problema s klasifikacijo ustvari tri vsebnike sklepanja.

Prvi vsebnik obravnava korake preoblikovanja funkcij. Nato vsebnik algoritma ustvari predicted_label z največjo verjetnostjo. Končno, vsebnik za sklepanje po obdelavi izvede inverzno transformacijo na predvideni oznaki in jo preslika v izvirno oznako. Za več informacij glejte Definicije vsebnika sklepanja za tipe problemov regresije in klasifikacije.

Izvlečemo te tri vsebnike sklepanja in jih razmestimo v ločene končne točke brez strežnika. Za sklepanje prikličemo končne točke v zaporedju, tako da koristni tovor najprej pošljemo v vsebnik za preoblikovanje lastnosti, nato posredujemo izhod iz tega vsebnika v vsebnik algoritma in končno posredujemo izhod iz prejšnjega vsebnika sklepanja v vsebnik za naknadno obdelavo, ki izpiše predvideno oznako.

Naslednji diagram ponazarja arhitekturo te nastavitve.

Izvlečemo tri vsebnike sklepanja iz BestCandidate z naslednjo kodo:

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)

Pošljite zahtevo za sklepanje usposobljenemu modelu

Za sklepanje pošiljamo koristni tovor v zaporedju: najprej v vsebnik pretvorbe funkcij, nato v vsebnik modela in nazadnje v vsebnik pretvorbe inverzne oznake.

Glej naslednjo kodo:

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

Celotna izvedba tega primera je na voljo v naslednjem jupyterju prenosnik.

Čiščenje

Če želite počistiti vire, lahko izbrišete ustvarjene brezstrežniške končne točke, konfiguracije končnih točk in modele:

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

zaključek

V tej objavi smo pokazali, kako lahko uvedemo modele, ustvarjene z avtopilotom, v ansambelskem in HPO načinu na končne točke sklepanja brez strežnika. Ta rešitev lahko pospeši vašo zmožnost uporabe in izkoriščanja stroškovno učinkovitih in popolnoma upravljanih storitev ML, kot je Autopilot, za hitro ustvarjanje modelov iz neobdelanih podatkov in njihovo uvajanje v popolnoma upravljane brezstrežniške končne točke sklepanja z vgrajenim samodejnim skaliranjem za zmanjšanje stroškov .

Priporočamo vam, da preizkusite to rešitev z naborom podatkov, ki ustrezajo KPI vašega podjetja. Lahko se sklicujete na rešitev, implementirano v prenosnem računalniku Jupyter v GitHub repo.

Dodatne reference

O Author

Praveen Chamarthi je višji strokovnjak za AI/ML pri Amazon Web Services. Navdušen je nad AI/ML in vsem, kar zadeva AWS. Strankam po vsej Ameriki pomaga pri prilagajanju, inoviranju in učinkovitem upravljanju delovnih obremenitev ML na AWS. V prostem času Praveen rad bere in uživa v znanstvenofantastičnih filmih.