Implementați modele Amazon SageMaker Autopilot în punctele finale de inferență fără server

Pilot automat cu Amazon SageMaker creează, antrenează și reglează automat cele mai bune modele de învățare automată (ML) pe baza datelor dvs., permițându-vă în același timp să mențineți controlul și vizibilitatea deplină. Autopilot poate implementa, de asemenea, modele instruite la punctele finale de inferență în timp real în mod automat.

Dacă aveți încărcături de lucru cu modele de trafic înțepenite sau imprevizibile care pot tolera pornirile la rece, atunci implementarea modelului la un punct final de inferență fără server ar fi mai eficientă din punct de vedere al costurilor.

Inferență fără server Amazon SageMaker este o opțiune de inferență creată special, ideală pentru sarcinile de lucru cu modele de trafic imprevizibile și care poate tolera pornirile la rece. Spre deosebire de un punct final de inferență în timp real, care este susținut de o instanță de calcul de lungă durată, punctele finale fără server furnizează resurse la cerere cu scalare automată încorporată. Punctele finale fără server se scalează automat în funcție de numărul de solicitări primite și reduc resursele la zero atunci când nu există solicitări primite, ajutându-vă să vă minimizați costurile.

În această postare, arătăm cum să implementăm modele antrenate cu Autopilot la punctele finale de inferență fără server folosind Biblioteci Boto3 pentru Amazon SageMaker.

Moduri de antrenament pentru pilot automat

Înainte de a crea un experiment Autopilot, puteți fie să-l lăsați pe Autopilot să selecteze automat modul de antrenament, fie îl puteți selecta manual.

Autopilot acceptă în prezent trei moduri de antrenament:

• Auto – Pe baza dimensiunii setului de date, Autopilot alege automat fie modul de ansamblu, fie modul HPO. Pentru seturile de date mai mari de 100 MB, Autopilot alege HPO; în caz contrar, alege asamblarea.
• Ansamblu – Pilotul automat folosește AutoGluon tehnica de asamblare folosind stivuirea modelelor și produce un model predictiv optim.
• Optimizarea hiperparametrului (HPO) – Autopilot găsește cea mai bună versiune a unui model prin reglarea hiperparametrilor utilizând optimizarea bayesiană sau optimizarea multi-fidelitate în timp ce rulează joburi de antrenament pe setul de date. Modul HPO selectează algoritmii cei mai relevanți pentru setul de date și selectează cea mai bună gamă de hiperparametri pentru a-ți regla modelele.

Pentru a afla mai multe despre modurile de antrenament Autopilot, consultați Moduri de antrenament.

Prezentare generală a soluțiilor

În această postare, folosim Marketing UCI Bank set de date pentru a prezice dacă un client va subscrie la un depozit la termen oferit de bancă. Acesta este un tip de problemă de clasificare binară.

Lansăm două joburi Autopilot folosind Biblioteci Boto3 pentru SageMaker. Primul loc de muncă folosește ansamblul ca mod de antrenament ales. Apoi implementăm modelul unic de ansamblu generat la un punct final fără server și trimitem cereri de inferență către acest punct final găzduit.

Al doilea job folosește modul de antrenament HPO. Pentru tipurile de probleme de clasificare, Autopilot generează trei containere de inferență. Extragem aceste trei containere de inferență și le implementăm în puncte finale fără server separate. Apoi trimitem cereri de inferență către aceste puncte finale găzduite.

Pentru mai multe informații despre tipurile de probleme de regresie și clasificare, consultați Definițiile containerului de inferență pentru tipurile de probleme de regresie și clasificare.

De asemenea, putem lansa joburi Autopilot din Amazon SageMaker Studio UI. Dacă lansați lucrări din interfața de utilizare, asigurați-vă că dezactivați Implementare automată opțiune în Setări de implementare și avansate secțiune. În caz contrar, Autopilot va implementa cel mai bun candidat la un punct final în timp real.

Cerințe preliminare

Asigurați-vă că aveți instalată cea mai recentă versiune de Boto3 și pachetele SageMaker Python:

pip install -U boto3 sagemaker

Avem nevoie de versiunea pachetului SageMaker >= 2.110.0 și versiunea Boto3 >= boto3-1.24.84.

Lansați o lucrare Autopilot cu modul de asamblare

Pentru a lansa un job Autopilot folosind bibliotecile SageMaker Boto3, folosim create_auto_ml_job API. Trecem apoi înăuntru AutoMLJobConfig, InputDataConfig, și AutoMLJobObjective ca intrări la create_auto_ml_job. Consultați următorul cod:

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 returnează BestCandidate obiect model care are InferenceContainers necesare pentru implementarea modelelor la punctele finale de inferență. Pentru a obține BestCandidate pentru jobul precedent, folosim describe_automl_job funcţie:

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)

Implementați modelul instruit

Acum implementăm containerul de inferență anterior într-un punct final fără server. Primul pas este să creați un model din containerul de inferență, apoi să creați o configurație de punct final în care să specificăm MemorySizeInMB și MaxConcurrency valorile pentru punctul final fără server împreună cu numele modelului. În cele din urmă, creăm un punct final cu configurația punctului final creată mai sus.

Vă recomandăm să vă alegeți dimensiunea memoriei punctului final în funcție de dimensiunea modelului dvs. Dimensiunea memoriei ar trebui să fie cel puțin la fel de mare ca dimensiunea modelului dvs. Punctul final fără server are o dimensiune RAM minimă de 1024 MB (1 GB), iar dimensiunea RAM maximă pe care o puteți alege este de 6144 MB (6 GB).

Dimensiunile de memorie pe care le puteți alege sunt 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB sau 6144 MB.

Pentru a determina dacă un punct final fără server este opțiunea de implementare potrivită din punct de vedere al costurilor și al performanței, vă încurajăm să consultați SageMaker Serverless Inference Benchmarking Toolkit, care testează diferite configurații ale punctelor finale și o compară pe cea mai optimă cu o instanță de găzduire comparabilă în timp real.

Rețineți că punctele finale fără server acceptă numai SingleModel pentru containere de inferență. Autopilot în modul de asamblare generează un singur model, astfel încât să putem implementa acest container de model așa cum este la punctul final. Vezi următorul cod:

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

Când punctul final de inferență fără server este InService, putem testa punctul final trimițând o cerere de inferență și observăm predicțiile. Următoarea diagramă ilustrează arhitectura acestei configurații.

Rețineți că putem trimite date brute ca sarcină utilă către punctul final. Modelul de ansamblu generat de Autopilot încorporează automat toți pașii necesari de transformare a caracteristicilor și de transformare a etichetei inverse, împreună cu modelul de algoritm și pachetele, într-un singur model.

Trimiteți cererea de inferență către modelul instruit

Utilizați următorul cod pentru a trimite inferențe asupra modelului dvs. antrenat folosind modul de asamblare:

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)

Lansați o lucrare Autopilot cu modul HPO

În modul HPO, pentru CompletionCriteria, în afară de MaxRuntimePerTrainingJobInSeconds și MaxAutoMLJobRuntimeInSeconds, am putea specifica, de asemenea, MaxCandidates pentru a limita numărul de candidați pe care îl va genera un job Autopilot. Rețineți că aceștia sunt parametri opționali și sunt setați doar pentru a limita timpul de execuție a jobului pentru demonstrație. Vezi următorul cod:

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
				)

Pentru a obține BestCandidate pentru jobul precedent, putem folosi din nou describe_automl_job funcţie:

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)

Implementați modelul instruit

Autopilot în modul HPO pentru tipul de problemă de clasificare generează trei containere de inferență.

Primul container se ocupă de pașii de transformare a caracteristicilor. Apoi, containerul de algoritm generează predicted_label cu cea mai mare probabilitate. În cele din urmă, containerul de inferență de post-procesare efectuează o transformare inversă pe eticheta prezisă și o mapează la eticheta originală. Pentru mai multe informații, consultați Definițiile containerului de inferență pentru tipurile de probleme de regresie și clasificare.

Extragem aceste trei containere de inferență și le implementăm într-un punct final separat fără server. Pentru inferență, invocăm punctele finale în secvență, trimițând mai întâi sarcina utilă către containerul de transformare a caracteristicilor, apoi trecând rezultatul din acest container către containerul de algoritm și, în final, trecând rezultatul din containerul de inferență anterior către containerul de post-procesare, care scoate eticheta prezisă.

Următoarea diagramă ilustrează arhitectura acestei configurații.

Extragem cele trei containere de inferență din BestCandidate cu următorul cod:

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)

Trimiteți cererea de inferență către modelul instruit

Pentru deducere, trimitem sarcina utilă în secvență: mai întâi către containerul de transformare a caracteristicilor, apoi către containerul model și, în sfârșit, către containerul de transformare cu etichetă inversă.

Consultați următorul cod:

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

Implementarea completă a acestui exemplu este disponibilă în următorul jupyter caiet.

A curăța

Pentru a curăța resurse, puteți șterge punctele finale fără server create, configurațiile punctelor finale și modelele:

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

Concluzie

În această postare, am arătat cum putem implementa modele generate de Autopilot atât în ​​modul ansamblu, cât și în modul HPO la punctele finale de inferență fără server. Această soluție vă poate accelera capacitatea de a utiliza și de a profita de serviciile ML eficiente din punct de vedere al costurilor și complet gestionate, cum ar fi Autopilot, pentru a genera rapid modele din date brute și apoi le poate implementa în punctele finale de inferență fără server complet gestionate cu scalare automată încorporată pentru a reduce costurile .

Vă încurajăm să încercați această soluție cu un set de date relevant pentru KPI-urile dvs. de afaceri. Vă puteți referi la soluția implementată într-un caiet Jupyter în GitHub repo.

Referințe suplimentare

Despre autor

Praveen Chamarthi este un Senior AI/ML Specialist cu Amazon Web Services. Este pasionat de AI/ML și de toate lucrurile AWS. El îi ajută pe clienții din America să extindă, să inoveze și să opereze eficient sarcinile de lucru ML pe AWS. În timpul liber, lui Praveen îi place să citească și îi plac filmele SF.