Distribuisci modelli Autopilot di Amazon SageMaker a endpoint di inferenza serverless

Ripubblicato da Platone

Seguaci: 0

Pilota automatico Amazon SageMaker crea, addestra e ottimizza automaticamente i migliori modelli di machine learning (ML) in base ai tuoi dati, consentendoti di mantenere il controllo e la visibilità completi. Autopilot può anche distribuire automaticamente modelli addestrati agli endpoint di inferenza in tempo reale.

Se disponi di carichi di lavoro con schemi di traffico elevati o imprevedibili che possono tollerare avviamenti a freddo, la distribuzione del modello su un endpoint di inferenza serverless sarebbe più conveniente.

Inferenza serverless di Amazon SageMaker è un'opzione di inferenza appositamente creata, ideale per carichi di lavoro con modelli di traffico imprevedibili e in grado di tollerare avviamenti a freddo. A differenza di un endpoint di inferenza in tempo reale, che è supportato da un'istanza di calcolo a esecuzione prolungata, gli endpoint serverless forniscono risorse on demand con ridimensionamento automatico integrato. Gli endpoint serverless si ridimensionano automaticamente in base al numero di richieste in arrivo e riducono le risorse a zero quando non ci sono richieste in arrivo, aiutandoti a ridurre al minimo i costi.

In questo post, mostriamo come distribuire i modelli addestrati di Autopilot agli endpoint di inferenza serverless utilizzando il Librerie Boto3 per Amazon Sage Maker.

Modalità di addestramento del pilota automatico

Prima di creare un esperimento di Autopilot, puoi consentire ad Autopilot di selezionare automaticamente la modalità di addestramento oppure puoi selezionare la modalità di addestramento manualmente.

Autopilot attualmente supporta tre modalità di addestramento:

Automatico – In base alle dimensioni del set di dati, Autopilot sceglie automaticamente la modalità di aggregazione o HPO. Per set di dati superiori a 100 MB, Autopilot sceglie HPO; in caso contrario, sceglie l'insieme.
assemblaggio – Il pilota automatico utilizza il AutoGluone tecnica di assemblaggio che utilizza l'impilamento del modello e produce un modello predittivo ottimale.
Ottimizzazione dell'iperparametro (HPO) – Autopilot trova la versione migliore di un modello ottimizzando gli iperparametri utilizzando l'ottimizzazione bayesiana o l'ottimizzazione multi-fidelity durante l'esecuzione di processi di addestramento sul set di dati. La modalità HPO seleziona gli algoritmi più rilevanti per il tuo set di dati e seleziona la migliore gamma di iperparametri per ottimizzare i tuoi modelli.

Per ulteriori informazioni sulle modalità di addestramento del pilota automatico, fare riferimento a Modalità di allenamento.

Panoramica della soluzione

In questo post, usiamo l'estensione Marketing bancario UCI set di dati per prevedere se un cliente sottoscriverà un deposito a termine offerto dalla banca. Questo è un tipo di problema di classificazione binaria.

Lanciamo due processi di Autopilot utilizzando il Librerie Boto3 per SageMaker. Il primo lavoro utilizza l'ensemble come modalità di addestramento prescelta. Quindi distribuiamo il modello di ensemble singolo generato a un endpoint serverless e inviamo richieste di inferenza a questo endpoint ospitato.

Il secondo lavoro utilizza la modalità di addestramento HPO. Per i tipi di problemi di classificazione, Autopilot genera tre contenitori di inferenza. Estraiamo questi tre contenitori di inferenza e li distribuiamo su endpoint serverless separati. Quindi inviamo richieste di inferenza a questi endpoint ospitati.

Per ulteriori informazioni sui tipi di problema di regressione e classificazione, fare riferimento a Definizioni di contenitori di inferenza per tipi di problemi di regressione e classificazione.

Possiamo anche avviare i lavori di Autopilot dal file Amazon Sage Maker Studio interfaccia utente. Se avvii lavori dall'interfaccia utente, assicurati di disattivare il file Distribuzione automatica opzione nel Distribuzione e impostazioni avanzate sezione. In caso contrario, Autopilot distribuirà il miglior candidato a un endpoint in tempo reale.

Prerequisiti

Assicurati di avere installato l'ultima versione di Boto3 e i pacchetti SageMaker Python:

pip install -U boto3 sagemaker

Abbiamo bisogno della versione del pacchetto SageMaker >= 2.110.0 e versione Boto3 >= boto3-1.24.84.

Avvia un processo Autopilot con la modalità di ensemble

Per avviare un lavoro Autopilot utilizzando le librerie SageMaker Boto3, utilizziamo il file create_auto_ml_job API. Passiamo quindi dentro AutoMLJobConfig, InputDataConfige AutoMLJobObjective come input al create_auto_ml_job. Vedi il seguente codice:

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)

Il pilota automatico restituisce il BestCandidate oggetto modello che ha il InferenceContainers necessario per distribuire i modelli agli endpoint di inferenza. Prendere il BestCandidate per il lavoro precedente, usiamo il describe_automl_job funzione:

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)

Distribuire il modello addestrato

Distribuiamo ora il contenitore di inferenza precedente in un endpoint senza server. Il primo passaggio consiste nel creare un modello dal contenitore di inferenza, quindi creare una configurazione dell'endpoint in cui specifichiamo il file MemorySizeInMB ed MaxConcurrency valori per l'endpoint serverless insieme al nome del modello. Infine, creiamo un endpoint con la configurazione dell'endpoint creata sopra.

Ti consigliamo di scegliere il tuo dimensione della memoria dell'endpoint in base alle dimensioni del modello. La dimensione della memoria deve essere grande almeno quanto la dimensione del modello. L'endpoint serverless ha una dimensione minima della RAM di 1024 MB (1 GB) e la dimensione massima della RAM che puoi scegliere è 6144 MB (6 GB).

Le dimensioni della memoria che puoi scegliere sono 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB o 6144 MB.

Per aiutare a determinare se un endpoint serverless è l'opzione di implementazione giusta dal punto di vista dei costi e delle prestazioni, ti invitiamo a fare riferimento a Kit di strumenti di benchmarking per inferenza serverless SageMaker, che verifica diverse configurazioni di endpoint e confronta quella più ottimale con un'istanza di hosting in tempo reale comparabile.

Si noti che gli endpoint serverless accettano solo SingleModel per i contenitori di inferenza. Il pilota automatico in modalità di insieme genera un singolo modello, quindi possiamo distribuire questo contenitore di modelli così com'è nell'endpoint. Vedere il seguente codice:

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

Quando l'endpoint di inferenza serverless è InService, possiamo testare l'endpoint inviando una richiesta di inferenza e osservare le previsioni. Il diagramma seguente illustra l'architettura di questa configurazione.

Tieni presente che possiamo inviare dati grezzi come payload all'endpoint. Il modello di ensemble generato da Autopilot incorpora automaticamente tutti i passaggi di trasformazione delle caratteristiche e delle etichette inverse richiesti, insieme al modello e ai pacchetti dell'algoritmo, in un unico modello.

Invia la richiesta di inferenza al modello addestrato

Usa il seguente codice per inviare l'inferenza sul tuo modello addestrato utilizzando la modalità di assemblaggio:

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)

Avvia un processo Autopilot con la modalità HPO

In modalità HPO, per CompletionCriteria, Oltretutto MaxRuntimePerTrainingJobInSeconds ed MaxAutoMLJobRuntimeInSeconds, potremmo anche specificare il MaxCandidates per limitare il numero di candidati generati da un processo di Autopilot. Si noti che questi sono parametri facoltativi e sono impostati solo per limitare il tempo di esecuzione del lavoro per la dimostrazione. Vedere il seguente codice:

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
				)

Prendere il BestCandidate per il lavoro precedente, possiamo usare nuovamente il file describe_automl_job funzione:

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)

Distribuire il modello addestrato

Il pilota automatico in modalità HPO per il tipo di problema di classificazione genera tre contenitori di inferenza.

Il primo contenitore gestisce i passaggi di trasformazione delle funzionalità. Successivamente, il contenitore dell'algoritmo genera il file predicted_label con la massima probabilità. Infine, il contenitore di inferenza post-elaborazione esegue una trasformazione inversa sull'etichetta prevista e la mappa all'etichetta originale. Per ulteriori informazioni, fare riferimento a Definizioni di contenitori di inferenza per tipi di problemi di regressione e classificazione.

Estraiamo questi tre contenitori di inferenza e li distribuiamo su endpoint serverless separati. Per l'inferenza, invochiamo gli endpoint in sequenza inviando prima il payload al contenitore di trasformazione delle caratteristiche, quindi passando l'output da questo contenitore al contenitore dell'algoritmo e infine passando l'output dal precedente contenitore di inferenza al contenitore di post-elaborazione, che restituisce l'etichetta prevista.

Il diagramma seguente illustra l'architettura di questa configurazione.

Estraiamo i tre contenitori di inferenza dal file BestCandidate con il seguente codice:

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)

Invia la richiesta di inferenza al modello addestrato

Per inferenza, inviamo il payload in sequenza: prima al contenitore di trasformazione delle caratteristiche, quindi al contenitore del modello e infine al contenitore di trasformazione dell'etichetta inversa.

visualizzazione del flusso di richiesta di inferenza di tre contenitori di inferenza dalla modalità HPO

Vedi il seguente codice:

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

L'implementazione completa di questo esempio è disponibile nel seguente jupyter taccuino.

ripulire

Per ripulire le risorse, puoi eliminare gli endpoint serverless creati, le configurazioni degli endpoint e i modelli:

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

Conclusione

In questo post, abbiamo mostrato come distribuire modelli generati da Autopilot sia in modalità ensemble che HPO su endpoint di inferenza serverless. Questa soluzione può velocizzare la tua capacità di utilizzare e sfruttare servizi ML economici e completamente gestiti come Autopilot per generare rapidamente modelli da dati non elaborati e quindi distribuirli a endpoint di inferenza serverless completamente gestiti con scalabilità automatica integrata per ridurre i costi .

Ti invitiamo a provare questa soluzione con un set di dati pertinente ai tuoi KPI aziendali. È possibile fare riferimento alla soluzione implementata in un notebook Jupyter nel file Repository GitHub.

Riferimenti aggiuntivi

L'autore

Praven Chamarthi è un Senior AI/ML Specialist con Amazon Web Services. È appassionato di AI/ML e di tutto ciò che riguarda AWS. Aiuta i clienti nelle Americhe a scalare, innovare e gestire i carichi di lavoro ML in modo efficiente su AWS. Nel suo tempo libero, Praveen ama leggere e godersi i film di fantascienza.