Terapkan model Amazon SageMaker Autopilot ke titik akhir inferensi tanpa server

Autopilot Amazon SageMaker secara otomatis membuat, melatih, dan menyetel model pembelajaran mesin (ML) terbaik berdasarkan data Anda, sekaligus memungkinkan Anda mempertahankan kontrol dan visibilitas penuh. Autopilot juga dapat menerapkan model terlatih ke titik akhir inferensi real-time secara otomatis.

Jika Anda memiliki beban kerja dengan pola lalu lintas yang tajam atau tidak dapat diprediksi yang dapat mentolerir cold start, menerapkan model ke titik akhir inferensi tanpa server akan lebih hemat biaya.

Inferensi Tanpa Server Amazon SageMaker adalah opsi inferensi yang dibangun khusus untuk beban kerja dengan pola lalu lintas yang tidak dapat diprediksi dan yang dapat mentolerir cold start. Tidak seperti titik akhir inferensi real-time, yang didukung oleh instans komputasi yang berjalan lama, titik akhir tanpa server menyediakan sumber daya sesuai permintaan dengan penskalaan otomatis bawaan. Titik akhir tanpa server menskalakan secara otomatis berdasarkan jumlah permintaan masuk dan menurunkan sumber daya menjadi nol saat tidak ada permintaan masuk, membantu Anda meminimalkan biaya.

Dalam postingan ini, kami menunjukkan cara menerapkan model terlatih Autopilot ke titik akhir inferensi tanpa server menggunakan Pustaka Boto3 untuk Amazon SageMaker.

Mode pelatihan autopilot

Sebelum membuat eksperimen Autopilot, Anda dapat membiarkan Autopilot memilih mode latihan secara otomatis, atau Anda dapat memilih mode latihan secara manual.

Autopilot saat ini mendukung tiga mode pelatihan:

• Mobil – Berdasarkan ukuran dataset, Autopilot secara otomatis memilih mode ensembling atau HPO. Untuk kumpulan data yang lebih besar dari 100 MB, Autopilot memilih HPO; jika tidak, ia memilih ensembel.
• Ansambling – Autopilot menggunakan Perekat Otomatis teknik ensembling menggunakan model stacking dan menghasilkan model prediksi yang optimal.
• Optimalisasi hyperparameter (HPO) – Autopilot menemukan versi terbaik dari sebuah model dengan menyetel hyperparameter menggunakan optimasi Bayesian atau optimasi multi-fidelitas saat menjalankan tugas pelatihan pada kumpulan data Anda. Mode HPO memilih algoritme yang paling relevan dengan kumpulan data Anda dan memilih rentang hyperparameter terbaik untuk menyempurnakan model Anda.

Untuk mempelajari lebih lanjut tentang mode pelatihan Autopilot, lihat Mode pelatihan.

Ikhtisar solusi

Dalam posting ini, kami menggunakan Pemasaran Bank UCI kumpulan data untuk memprediksi apakah klien akan berlangganan deposito berjangka yang ditawarkan oleh bank. Ini adalah jenis masalah klasifikasi biner.

Kami meluncurkan dua pekerjaan Autopilot menggunakan Pustaka Boto3 untuk SageMaker. Pekerjaan pertama menggunakan ensembling sebagai mode pelatihan yang dipilih. Kami kemudian menerapkan model ansambel tunggal yang dihasilkan ke titik akhir tanpa server dan mengirimkan permintaan inferensi ke titik akhir yang dihosting ini.

Pekerjaan kedua menggunakan mode pelatihan HPO. Untuk jenis masalah klasifikasi, Autopilot menghasilkan tiga kontainer inferensi. Kami mengekstrak ketiga wadah inferensi ini dan menerapkannya ke titik akhir tanpa server yang terpisah. Kemudian kami mengirimkan permintaan inferensi ke titik akhir yang dihosting ini.

Untuk informasi selengkapnya tentang jenis masalah regresi dan klasifikasi, lihat Definisi wadah inferensi untuk jenis masalah regresi dan klasifikasi.

Kami juga dapat meluncurkan pekerjaan Autopilot dari Studio Amazon SageMaker UI. Jika Anda meluncurkan tugas dari UI, pastikan untuk mematikan Penyebaran otomatis pilihan dalam Penyebaran dan pengaturan Lanjutan bagian. Jika tidak, Autopilot akan menerapkan kandidat terbaik ke titik akhir waktu nyata.

Prasyarat

Pastikan Anda memiliki Boto3 versi terbaru dan paket SageMaker Python terinstal:

pip install -U boto3 sagemaker

Kami membutuhkan versi paket SageMaker >= 2.110.0 dan versi Boto3 >= boto3-1.24.84.

Luncurkan tugas Autopilot dengan mode ensembling

Untuk meluncurkan tugas Autopilot menggunakan pustaka SageMaker Boto3, kami menggunakan buat_auto_ml_job API. Kami kemudian lewat AutoMLJobConfig, InputDataConfig, dan AutoMLJobObjective sebagai masukan untuk create_auto_ml_job. Lihat kode berikut:

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 mengembalikan BestCandidate objek model yang memiliki InferenceContainers diperlukan untuk menyebarkan model ke titik akhir inferensi. Untuk mendapatkan BestCandidate untuk pekerjaan sebelumnya, kami menggunakan describe_automl_job fungsi:

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)

Terapkan model yang dilatih

Kami sekarang menerapkan wadah inferensi sebelumnya ke titik akhir tanpa server. Langkah pertama adalah membuat model dari wadah inferensi, lalu membuat konfigurasi titik akhir tempat kami menentukan MemorySizeInMB dan MaxConcurrency nilai untuk titik akhir tanpa server bersama dengan nama model. Terakhir, kami membuat titik akhir dengan konfigurasi titik akhir yang dibuat di atas.

Kami sarankan memilih Anda ukuran memori titik akhir sesuai dengan ukuran model Anda. Ukuran memori setidaknya harus sebesar ukuran model Anda. Titik akhir tanpa server Anda memiliki ukuran RAM minimum 1024 MB (1 GB), dan ukuran RAM maksimum yang dapat Anda pilih adalah 6144 MB (6 GB).

Ukuran memori yang dapat Anda pilih adalah 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB, atau 6144 MB.

Untuk membantu menentukan apakah titik akhir tanpa server merupakan opsi penerapan yang tepat dari perspektif biaya dan kinerja, sebaiknya Anda merujuk ke Perangkat Pembandingan Inferensi Tanpa Server SageMaker, yang menguji konfigurasi titik akhir yang berbeda dan membandingkan yang paling optimal dengan instans hosting waktu nyata yang sebanding.

Perhatikan bahwa titik akhir tanpa server hanya menerima SingleModel untuk wadah inferensi. Autopilot dalam mode ensembling menghasilkan satu model, sehingga kami dapat menerapkan wadah model ini seperti pada titik akhir. Lihat kode berikut:

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

Saat titik akhir inferensi tanpa server adalah InService, kita dapat menguji titik akhir dengan mengirimkan permintaan inferensi dan mengamati prediksinya. Diagram berikut mengilustrasikan arsitektur pengaturan ini.

Perhatikan bahwa kami dapat mengirim data mentah sebagai muatan ke titik akhir. Model ansambel yang dihasilkan oleh Autopilot secara otomatis menggabungkan semua langkah transformasi fitur dan label terbalik yang diperlukan, bersama dengan model algoritme dan paket, ke dalam satu model.

Kirim permintaan inferensi ke model terlatih

Gunakan kode berikut untuk mengirimkan inferensi pada model Anda yang dilatih menggunakan mode ensembling:

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)

Luncurkan Pekerjaan Autopilot dengan mode HPO

Dalam mode HPO, untuk CompletionCriteriaselain itu MaxRuntimePerTrainingJobInSeconds dan MaxAutoMLJobRuntimeInSeconds, kita juga bisa menentukan MaxCandidates untuk membatasi jumlah kandidat yang dihasilkan oleh pekerjaan Autopilot. Perhatikan bahwa ini adalah parameter opsional dan hanya diatur untuk membatasi runtime pekerjaan untuk demonstrasi. Lihat kode berikut:

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
				)

Untuk mendapatkan BestCandidate untuk pekerjaan sebelumnya, kita dapat kembali menggunakan describe_automl_job fungsi:

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)

Terapkan model yang dilatih

Autopilot dalam mode HPO untuk jenis masalah klasifikasi menghasilkan tiga kontainer inferensi.

Wadah pertama menangani langkah-langkah transformasi fitur. Selanjutnya, wadah algoritma menghasilkan predicted_label dengan probabilitas tertinggi. Akhirnya, wadah inferensi pasca-pemrosesan melakukan transformasi terbalik pada label yang diprediksi dan memetakannya ke label aslinya. Untuk informasi lebih lanjut, lihat Definisi wadah inferensi untuk jenis masalah regresi dan klasifikasi.

Kami mengekstrak ketiga wadah inferensi ini dan menerapkannya ke titik akhir tanpa server yang terpisah. Untuk inferensi, kami memanggil titik akhir secara berurutan dengan mengirimkan payload terlebih dahulu ke wadah transformasi fitur, lalu meneruskan keluaran dari wadah ini ke wadah algoritme, dan terakhir meneruskan keluaran dari wadah inferensi sebelumnya ke wadah pasca-pemrosesan, yang menampilkan label yang diprediksi.

Diagram berikut mengilustrasikan arsitektur pengaturan ini.

Kami mengekstrak tiga wadah inferensi dari BestCandidate dengan kode berikut:

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)

Kirim permintaan inferensi ke model terlatih

Untuk inferensi, kami mengirim payload secara berurutan: pertama ke container transformasi fitur, lalu ke container model, dan terakhir ke container transformasi inverse-label.

Lihat kode berikut:

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

Implementasi penuh dari contoh ini tersedia di jupyter berikut buku catatan.

Membersihkan

Untuk membersihkan resource, Anda dapat menghapus endpoint, konfigurasi endpoint, dan model tanpa server yang dibuat:

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

Kesimpulan

Dalam posting ini, kami menunjukkan bagaimana kami dapat menerapkan model yang dihasilkan Autopilot baik dalam mode ansambel dan HPO ke titik akhir inferensi tanpa server. Solusi ini dapat mempercepat kemampuan Anda untuk menggunakan dan memanfaatkan layanan ML yang hemat biaya dan terkelola sepenuhnya seperti Autopilot untuk membuat model dengan cepat dari data mentah, lalu menerapkannya ke titik akhir inferensi tanpa server yang terkelola sepenuhnya dengan penskalaan otomatis bawaan untuk mengurangi biaya .

Kami mendorong Anda untuk mencoba solusi ini dengan kumpulan data yang relevan dengan KPI bisnis Anda. Anda dapat merujuk ke solusi yang diimplementasikan dalam notebook Jupyter di GitHub repo.

Referensi tambahan

tentang Penulis

Praveen Chamarthi adalah Spesialis AI/ML Senior di Amazon Web Services. Dia sangat menyukai AI/ML dan semua hal tentang AWS. Dia membantu pelanggan di seluruh Amerika untuk menskalakan, berinovasi, dan mengoperasikan beban kerja ML secara efisien di AWS. Di waktu luangnya, Praveen suka membaca dan menikmati film sci-fi.