ปรับใช้โมเดล Amazon SageMaker Autopilot กับปลายทางการอนุมานแบบไร้เซิร์ฟเวอร์

ระบบนำร่องอัตโนมัติของ Amazon SageMaker สร้าง ฝึกฝน และปรับแต่งโมเดลแมชชีนเลิร์นนิง (ML) ที่ดีที่สุดโดยอัตโนมัติตามข้อมูลของคุณ ในขณะเดียวกันก็ให้คุณควบคุมและมองเห็นได้อย่างเต็มที่ ระบบขับเคลื่อนอัตโนมัติยังสามารถปรับใช้โมเดลที่ผ่านการฝึกอบรมไปยังจุดสิ้นสุดการอนุมานตามเวลาจริงได้โดยอัตโนมัติ

หากคุณมีปริมาณงานที่มีรูปแบบการรับส่งข้อมูลที่ไม่แน่นอนหรือคาดเดาไม่ได้ซึ่งสามารถทนต่อการเริ่มเย็นได้ การปรับใช้โมเดลกับจุดสิ้นสุดการอนุมานแบบไร้เซิร์ฟเวอร์จะคุ้มค่ากว่า

การอนุมานแบบไร้เซิร์ฟเวอร์ของ Amazon SageMaker เป็นตัวเลือกการอนุมานที่สร้างขึ้นตามวัตถุประสงค์ซึ่งเหมาะสำหรับปริมาณงานที่มีรูปแบบการรับส่งข้อมูลที่คาดเดาไม่ได้และสามารถทนต่อการสตาร์ทเย็นได้ ซึ่งแตกต่างจากจุดสิ้นสุดการอนุมานตามเวลาจริงซึ่งได้รับการสนับสนุนโดยอินสแตนซ์การประมวลผลที่ใช้เวลานาน จุดสิ้นสุดแบบไร้เซิร์ฟเวอร์จัดเตรียมทรัพยากรตามความต้องการด้วยการปรับขนาดอัตโนมัติในตัว ตำแหน่งข้อมูลแบบไร้เซิร์ฟเวอร์ปรับขนาดโดยอัตโนมัติตามจำนวนคำขอที่เข้ามา และลดขนาดทรัพยากรให้เป็นศูนย์เมื่อไม่มีคำขอเข้ามา ช่วยให้คุณลดค่าใช้จ่ายได้

ในโพสต์นี้ เราจะแสดงวิธีการปรับใช้โมเดลที่ผ่านการฝึกอบรม Autopilot กับจุดสิ้นสุดการอนุมานแบบไร้เซิร์ฟเวอร์โดยใช้ ห้องสมุด Boto3 for อเมซอน SageMaker.

โหมดการฝึกอบรมอัตโนมัติ

ก่อนสร้างการทดสอบ Autopilot คุณสามารถให้ Autopilot เลือกโหมดการฝึกโดยอัตโนมัติ หรือเลือกโหมดการฝึกด้วยตนเองก็ได้

ขณะนี้ Autopilot รองรับโหมดการฝึกอบรมสามโหมด:

• รถยนต์ – ตามขนาดชุดข้อมูล Autopilot จะเลือกโหมด ensemble หรือ HPO โดยอัตโนมัติ สำหรับชุดข้อมูลที่มีขนาดใหญ่กว่า 100 MB Autopilot จะเลือก HPO มิฉะนั้นจะเลือกชุด
• การประกอบ – Autopilot ใช้ ออโต้กลูออน เทคนิคการประกอบโดยใช้การซ้อนแบบจำลองและสร้างแบบจำลองการทำนายที่เหมาะสมที่สุด
• การเพิ่มประสิทธิภาพพารามิเตอร์หลายมิติ (HPO) – ระบบขับเคลื่อนอัตโนมัติค้นหารุ่นที่ดีที่สุดของโมเดลโดยการปรับไฮเปอร์พารามิเตอร์โดยใช้การปรับให้เหมาะสมแบบเบย์หรือการเพิ่มประสิทธิภาพแบบหลายจุดในขณะที่เรียกใช้งานการฝึกอบรมในชุดข้อมูลของคุณ โหมด HPO จะเลือกอัลกอริทึมที่เกี่ยวข้องกับชุดข้อมูลของคุณมากที่สุด และเลือกช่วงไฮเปอร์พารามิเตอร์ที่ดีที่สุดเพื่อปรับแต่งโมเดลของคุณ

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโหมดการฝึกอบรม Autopilot โปรดดูที่ โหมดการฝึกอบรม.

ภาพรวมโซลูชัน

ในโพสต์นี้เราใช้ การตลาดธนาคาร UCI ชุดข้อมูลเพื่อคาดการณ์ว่าลูกค้าจะสมัครรับเงินฝากประจำที่เสนอโดยธนาคารหรือไม่ นี่คือประเภทของปัญหาการจำแนกประเภทไบนารี

เราเปิดตัวงาน Autopilot สองงานโดยใช้ ไลบรารี Boto3 สำหรับ SageMaker. งานแรกใช้การรวมกันเป็นโหมดการฝึกอบรมที่เลือก จากนั้นเราจะปรับใช้โมเดลชุดเดียวที่สร้างขึ้นไปยังจุดสิ้นสุดแบบไร้เซิร์ฟเวอร์ และส่งคำขอการอนุมานไปยังจุดสิ้นสุดที่เป็นโฮสต์นี้

งานที่สองใช้โหมดการฝึกอบรม HPO สำหรับประเภทปัญหาการจัดหมวดหมู่ Autopilot จะสร้างคอนเทนเนอร์การอนุมานสามรายการ เราแยกคอนเทนเนอร์การอนุมานทั้งสามนี้และปรับใช้กับจุดสิ้นสุดแบบไร้เซิร์ฟเวอร์ที่แยกจากกัน จากนั้นเราจะส่งคำขอการอนุมานไปยังปลายทางที่เป็นโฮสต์เหล่านี้

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับประเภทของปัญหาการถดถอยและการจำแนกประเภท โปรดดูที่ คำจำกัดความคอนเทนเนอร์การอนุมานสำหรับประเภทปัญหาการถดถอยและการจำแนกประเภท.

เรายังสามารถเปิดงาน Autopilot จาก สตูดิโอ Amazon SageMaker UI หากคุณเปิดงานจาก UI อย่าลืมปิด ปรับใช้อัตโนมัติ ตัวเลือกใน การปรับใช้และการตั้งค่าขั้นสูง ส่วน. มิฉะนั้น Autopilot จะปรับใช้ตัวเลือกที่ดีที่สุดไปยังจุดสิ้นสุดแบบเรียลไทม์

เบื้องต้น

ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้งแพ็คเกจ Boto3 และ SageMaker Python เวอร์ชันล่าสุดแล้ว:

pip install -U boto3 sagemaker

เราต้องการเวอร์ชันแพ็คเกจ SageMaker >= 2.110.0 และรุ่น Boto3 >= boto3-1.24.84.

เริ่มงาน Autopilot ด้วยโหมด ensemble

ในการเริ่มงาน Autopilot โดยใช้ไลบรารี SageMaker Boto3 เราใช้ create_auto_ml_job เอพีไอ เราก็ผ่านเข้ามา AutoMLJobConfig, InputDataConfigและ AutoMLJobObjective เป็นอินพุตให้กับ create_auto_ml_job. ดูรหัสต่อไปนี้:

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 ส่งคืนไฟล์ BestCandidate วัตถุรุ่นที่มี InferenceContainers จำเป็นต้องปรับใช้โมเดลเพื่ออนุมานจุดสิ้นสุด เพื่อให้ได้ BestCandidate สำหรับงานก่อนหน้าเราใช้ describe_automl_job ฟังก์ชั่น:

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)

ปรับใช้โมเดลที่ผ่านการฝึกอบรม

ตอนนี้เราปรับใช้คอนเทนเนอร์การอนุมานก่อนหน้านี้กับปลายทางแบบไร้เซิร์ฟเวอร์ ขั้นตอนแรกคือการสร้างโมเดลจากคอนเทนเนอร์การอนุมาน จากนั้นสร้างการกำหนดค่าปลายทางที่เราระบุ MemorySizeInMB และ MaxConcurrency ค่าสำหรับปลายทางแบบไร้เซิร์ฟเวอร์พร้อมกับชื่อรุ่น สุดท้าย เราสร้างจุดสิ้นสุดด้วยการกำหนดค่าจุดสิ้นสุดที่สร้างขึ้นด้านบน

เราขอแนะนำให้คุณเลือก ขนาดหน่วยความจำของปลายทาง ตามขนาดรุ่นของคุณ ขนาดหน่วยความจำควรใหญ่เท่ากับขนาดโมเดลของคุณเป็นอย่างน้อย ตำแหน่งข้อมูลแบบไร้เซิร์ฟเวอร์ของคุณมีขนาด RAM ขั้นต่ำ 1024 MB (1 GB) และขนาด RAM สูงสุดที่คุณสามารถเลือกได้คือ 6144 MB (6 GB)

ขนาดหน่วยความจำที่คุณสามารถเลือกได้คือ 1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB หรือ 6144 MB

เพื่อช่วยในการพิจารณาว่าปลายทางแบบไร้เซิร์ฟเวอร์เป็นตัวเลือกการปรับใช้ที่เหมาะสมจากมุมมองด้านต้นทุนและประสิทธิภาพหรือไม่ เราขอแนะนำให้คุณอ้างอิงถึง ชุดเครื่องมือเปรียบเทียบการอนุมานแบบไร้เซิร์ฟเวอร์ของ SageMakerซึ่งทดสอบการกำหนดค่าปลายทางต่างๆ และเปรียบเทียบการกำหนดค่าที่เหมาะสมที่สุดกับอินสแตนซ์โฮสติ้งแบบเรียลไทม์ที่เปรียบเทียบกันได้

โปรดทราบว่าปลายทางแบบไร้เซิร์ฟเวอร์ยอมรับเท่านั้น SingleModel สำหรับคอนเทนเนอร์อนุมาน Autopilot ในโหมด ensembling จะสร้างโมเดลเดียว ดังนั้นเราสามารถนำโมเดลคอนเทนเนอร์นี้ไปใช้กับ endpoint ได้ ดูรหัสต่อไปนี้:

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

เมื่อจุดสิ้นสุดการอนุมานแบบไร้เซิร์ฟเวอร์คือ InServiceเราสามารถทดสอบจุดสิ้นสุดได้โดยส่งคำขอการอนุมานและสังเกตการคาดคะเน ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมของการตั้งค่านี้

โปรดทราบว่าเราสามารถส่งข้อมูลดิบเป็นเพย์โหลดไปยังปลายทางได้ โมเดลทั้งมวลที่สร้างขึ้นโดย Autopilot จะรวมเอาขั้นตอนการแปลงฟีเจอร์และการแปลงป้ายกำกับแบบผกผันที่จำเป็นทั้งหมดโดยอัตโนมัติ พร้อมกับโมเดลอัลกอริทึมและแพ็คเกจเข้าไว้ในโมเดลเดียว

ส่งคำขอการอนุมานไปยังโมเดลที่ผ่านการฝึกอบรม

ใช้รหัสต่อไปนี้เพื่อส่งการอนุมานเกี่ยวกับโมเดลของคุณที่ได้รับการฝึกฝนโดยใช้โหมดการรวม:

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)

เริ่มงาน Autopilot ด้วยโหมด HPO

ในโหมด HPO สำหรับ CompletionCriteriaนอกจากนี้ MaxRuntimePerTrainingJobInSeconds และ MaxAutoMLJobRuntimeInSeconds, เรายังสามารถระบุ MaxCandidates เพื่อจำกัดจำนวนผู้สมัครที่งาน Autopilot จะสร้าง โปรดทราบว่าสิ่งเหล่านี้เป็นพารามิเตอร์ทางเลือกและถูกตั้งค่าให้จำกัดรันไทม์ของงานสำหรับการสาธิตเท่านั้น ดูรหัสต่อไปนี้:

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
				)

เพื่อให้ได้ BestCandidate สำหรับงานก่อนหน้า เราสามารถใช้อีกครั้ง describe_automl_job ฟังก์ชั่น:

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)

ปรับใช้โมเดลที่ผ่านการฝึกอบรม

ระบบขับเคลื่อนอัตโนมัติในโหมด HPO สำหรับประเภทปัญหาการจำแนกประเภทจะสร้างคอนเทนเนอร์การอนุมานสามรายการ

คอนเทนเนอร์แรกจัดการขั้นตอนการเปลี่ยนคุณลักษณะ ถัดไป คอนเทนเนอร์อัลกอริทึมจะสร้าง predicted_label ด้วยความเป็นไปได้สูงสุด สุดท้าย คอนเทนเนอร์การอนุมานหลังการประมวลผลจะทำการแปลงผกผันบนฉลากที่คาดคะเนและแมปกับฉลากดั้งเดิม สำหรับข้อมูลเพิ่มเติม โปรดดูที่ คำจำกัดความคอนเทนเนอร์การอนุมานสำหรับประเภทปัญหาการถดถอยและการจำแนกประเภท.

เราแยกคอนเทนเนอร์การอนุมานทั้งสามนี้และปรับใช้กับจุดสิ้นสุดแบบไร้เซิร์ฟเวอร์ที่แยกจากกัน สำหรับการอนุมาน เราเรียกใช้จุดสิ้นสุดตามลำดับโดยส่งเพย์โหลดไปยังคอนเทนเนอร์การแปลงคุณลักษณะก่อน จากนั้นจึงส่งเอาต์พุตจากคอนเทนเนอร์นี้ไปยังคอนเทนเนอร์อัลกอริทึม และสุดท้ายส่งผ่านเอาต์พุตจากคอนเทนเนอร์การอนุมานก่อนหน้าไปยังคอนเทนเนอร์หลังการประมวลผล ซึ่งจะแสดงผลฉลากที่คาดการณ์ไว้

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมของการตั้งค่านี้

เราแยกคอนเทนเนอร์การอนุมานทั้งสามออกจาก BestCandidate ด้วยรหัสต่อไปนี้:

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)

ส่งคำขอการอนุมานไปยังโมเดลที่ผ่านการฝึกอบรม

สำหรับการอนุมาน เราจะส่งเพย์โหลดตามลำดับ: อันดับแรกไปที่คอนเทนเนอร์การแปลงคุณลักษณะ จากนั้นไปที่คอนเทนเนอร์แบบจำลอง และสุดท้ายไปยังคอนเทนเนอร์การแปลงฉลากผกผัน

ดูรหัสต่อไปนี้:

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

การดำเนินการตามตัวอย่างนี้มีให้ใน jupyter ต่อไปนี้ สมุดบันทึก.

ทำความสะอาด

ในการล้างข้อมูลทรัพยากร คุณสามารถลบจุดสิ้นสุดแบบไร้เซิร์ฟเวอร์ที่สร้างขึ้น การกำหนดค่าจุดสิ้นสุด และโมเดล:

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

สรุป

ในโพสต์นี้ เราแสดงวิธีการปรับใช้โมเดลที่สร้างโดย Autopilot ทั้งในโหมด ensemble และ HPO ไปยังจุดสิ้นสุดการอนุมานแบบไร้เซิร์ฟเวอร์ โซลูชันนี้สามารถเพิ่มความเร็วให้กับความสามารถของคุณในการใช้งานและใช้ประโยชน์จากบริการ ML ที่มีการจัดการเต็มรูปแบบและประหยัดค่าใช้จ่าย เช่น Autopilot เพื่อสร้างโมเดลอย่างรวดเร็วจากข้อมูลดิบ จากนั้นปรับใช้กับจุดสิ้นสุดการอนุมานแบบไร้เซิร์ฟเวอร์ที่มีการจัดการเต็มรูปแบบพร้อมการปรับขนาดอัตโนมัติในตัวเพื่อลดค่าใช้จ่าย .

เราขอแนะนำให้คุณลองใช้โซลูชันนี้กับชุดข้อมูลที่เกี่ยวข้องกับ KPI ของธุรกิจของคุณ คุณสามารถอ้างถึงโซลูชันที่ใช้ในโน้ตบุ๊ก Jupyter ใน repo GitHub.

ข้อมูลอ้างอิงเพิ่มเติม

เกี่ยวกับผู้เขียน

ประวีณ จามรธี เป็นผู้เชี่ยวชาญด้าน AI/ML อาวุโสของ Amazon Web Services เขาหลงใหลเกี่ยวกับ AI/ML และทุกสิ่งของ AWS เขาช่วยลูกค้าทั่วอเมริกาในการปรับขนาด สร้างสรรค์ และดำเนินการกับปริมาณงาน ML อย่างมีประสิทธิภาพบน AWS เวลาว่างประวีณชอบอ่านหนังสือและชอบดูหนังไซไฟ