Amazon SageMaker ऑटोपायलट मॉडल को सर्वर रहित इंट्रेंस एंडपॉइंट पर तैनात करें

अमेज़ॅन सैजमेकर ऑटोपायलट आपके डेटा के आधार पर स्वचालित रूप से सर्वोत्तम मशीन लर्निंग (एमएल) मॉडल बनाता है, प्रशिक्षित करता है और ट्यून करता है, साथ ही आपको पूर्ण नियंत्रण और दृश्यता बनाए रखने की अनुमति देता है। ऑटोपायलट प्रशिक्षित मॉडलों को स्वचालित रूप से वास्तविक समय के अनुमान समापन बिंदुओं पर भी तैनात कर सकता है।

यदि आपके पास तेज या अप्रत्याशित ट्रैफ़िक पैटर्न वाला कार्यभार है जो ठंडी शुरुआत को सहन कर सकता है, तो मॉडल को सर्वर रहित अनुमान समापन बिंदु पर तैनात करना अधिक लागत प्रभावी होगा।

अमेज़ॅन सेजमेकर सर्वर रहित अनुमान यह एक उद्देश्य-निर्मित अनुमान विकल्प है जो अप्रत्याशित ट्रैफ़िक पैटर्न वाले कार्यभार के लिए आदर्श है और जो ठंडी शुरुआत को सहन कर सकता है। वास्तविक समय अनुमान समापन बिंदु के विपरीत, जो एक लंबे समय तक चलने वाले गणना उदाहरण द्वारा समर्थित है, सर्वर रहित समापन बिंदु अंतर्निहित ऑटो स्केलिंग के साथ मांग पर संसाधनों का प्रावधान करता है। सर्वर रहित एंडपॉइंट आने वाले अनुरोधों की संख्या के आधार पर स्वचालित रूप से स्केल करता है और कोई आने वाले अनुरोध नहीं होने पर संसाधनों को शून्य तक स्केल कर देता है, जिससे आपको अपनी लागत कम करने में मदद मिलती है।

इस पोस्ट में, हम दिखाते हैं कि ऑटोपायलट प्रशिक्षित मॉडल को सर्वर रहित अनुमान समापन बिंदुओं पर कैसे तैनात किया जाए Boto3 पुस्तकालय एसटी अमेज़न SageMaker.

ऑटोपायलट प्रशिक्षण मोड

ऑटोपायलट प्रयोग बनाने से पहले, आप या तो ऑटोपायलट को स्वचालित रूप से प्रशिक्षण मोड का चयन करने दे सकते हैं, या आप मैन्युअल रूप से प्रशिक्षण मोड का चयन कर सकते हैं।

ऑटोपायलट वर्तमान में तीन प्रशिक्षण मोड का समर्थन करता है:

• ऑटो - डेटासेट आकार के आधार पर, ऑटोपायलट स्वचालित रूप से या तो एन्सेम्बलिंग या एचपीओ मोड चुनता है। 100 एमबी से बड़े डेटासेट के लिए, ऑटोपायलट एचपीओ चुनता है; अन्यथा, यह संयोजन चुनता है।
• कोडांतरण - ऑटोपायलट का उपयोग करता है ऑटोग्लून मॉडल स्टैकिंग का उपयोग करके संयोजन तकनीक और एक इष्टतम पूर्वानुमानित मॉडल तैयार करता है।
• हाइपरपैरामीटर ऑप्टिमाइज़ेशन (HPO) - ऑटोपायलट आपके डेटासेट पर प्रशिक्षण कार्य चलाते समय बायेसियन ऑप्टिमाइज़ेशन या मल्टी-फ़िडेलिटी ऑप्टिमाइज़ेशन का उपयोग करके हाइपरपैरामीटर को ट्यून करके मॉडल का सबसे अच्छा संस्करण ढूंढता है। एचपीओ मोड आपके डेटासेट के लिए सबसे अधिक प्रासंगिक एल्गोरिदम का चयन करता है और आपके मॉडल को ट्यून करने के लिए हाइपरपैरामीटर की सर्वोत्तम श्रेणी का चयन करता है।

ऑटोपायलट प्रशिक्षण मोड के बारे में अधिक जानने के लिए, देखें प्रशिक्षण मोड.

समाधान अवलोकन

इस पोस्ट में, हम उपयोग करते हैं यूसीआई बैंक मार्केटिंग यह अनुमान लगाने के लिए डेटासेट कि क्या कोई ग्राहक बैंक द्वारा प्रस्तावित सावधि जमा की सदस्यता लेगा। यह एक द्विआधारी वर्गीकरण समस्या प्रकार है।

हम इसका उपयोग करके दो ऑटोपायलट कार्य लॉन्च करते हैं सेजमेकर के लिए Boto3 लाइब्रेरी. पहला काम चुने हुए प्रशिक्षण मोड के रूप में संयोजन का उपयोग करता है। फिर हम सर्वर रहित एंडपॉइंट पर जेनरेट किए गए एकल एन्सेम्बल मॉडल को तैनात करते हैं और इस होस्टेड एंडपॉइंट पर अनुमान अनुरोध भेजते हैं।

दूसरा कार्य एचपीओ प्रशिक्षण मोड का उपयोग करता है। वर्गीकरण समस्या प्रकारों के लिए, ऑटोपायलट तीन अनुमान कंटेनर उत्पन्न करता है। हम इन तीन अनुमान कंटेनरों को निकालते हैं और उन्हें अलग-अलग सर्वर रहित समापन बिंदुओं पर तैनात करते हैं। फिर हम इन होस्ट किए गए एंडपॉइंट्स पर अनुमान अनुरोध भेजते हैं।

प्रतिगमन और वर्गीकरण समस्या प्रकारों के बारे में अधिक जानकारी के लिए, देखें प्रतिगमन और वर्गीकरण समस्या प्रकारों के लिए अनुमान कंटेनर परिभाषाएँ.

हम ऑटोपायलट नौकरियां भी लॉन्च कर सकते हैं अमेज़ॅन सैजमेकर स्टूडियो यूआई. यदि आप यूआई से कार्य लॉन्च करते हैं, तो इसे बंद करना सुनिश्चित करें ऑटो परिनियोजन में विकल्प परिनियोजन और उन्नत सेटिंग्स अनुभाग। अन्यथा, ऑटोपायलट सर्वश्रेष्ठ उम्मीदवार को वास्तविक समय के समापन बिंदु पर तैनात करेगा।

.. पूर्वापेक्षाएँ

सुनिश्चित करें कि आपके पास Boto3 और SageMaker Python पैकेज का नवीनतम संस्करण स्थापित है:

pip install -U boto3 sagemaker

हमें सेजमेकर पैकेज संस्करण की आवश्यकता है >= 2.110.0 और Boto3 संस्करण >= boto3-1.24.84.

एन्सेम्बलिंग मोड के साथ ऑटोपायलट कार्य लॉन्च करें

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)

ऑटोपायलट लौटाता है 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 मॉडल नाम के साथ सर्वर रहित समापन बिंदु के लिए मान। अंत में, हम ऊपर बनाए गए एंडपॉइंट कॉन्फ़िगरेशन के साथ एक एंडपॉइंट बनाते हैं।

हम आपको चुनने की सलाह देते हैं समापन बिंदु की मेमोरी का आकार आपके मॉडल आकार के अनुसार. मेमोरी का आकार कम से कम आपके मॉडल के आकार जितना बड़ा होना चाहिए। आपके सर्वर रहित एंडपॉइंट का न्यूनतम रैम आकार 1024 एमबी (1 जीबी) है, और अधिकतम रैम आकार जो आप चुन सकते हैं वह 6144 एमबी (6 जीबी) है।

आप जो मेमोरी आकार चुन सकते हैं वे हैं 1024 एमबी, 2048 एमबी, 3072 एमबी, 4096 एमबी, 5120 एमबी, या 6144 एमबी।

यह निर्धारित करने में सहायता के लिए कि क्या सर्वर रहित एंडपॉइंट लागत और प्रदर्शन के नजरिए से सही परिनियोजन विकल्प है, हम आपको इसका संदर्भ लेने के लिए प्रोत्साहित करते हैं सेजमेकर सर्वर रहित अनुमान बेंचमार्किंग टूलकिट, जो विभिन्न एंडपॉइंट कॉन्फ़िगरेशन का परीक्षण करता है और तुलनीय रीयल-टाइम होस्टिंग इंस्टेंस के विरुद्ध सबसे इष्टतम की तुलना करता है।

ध्यान दें कि सर्वर रहित एंडपॉइंट केवल स्वीकार करते हैं SingleModel अनुमान कंटेनरों के लिए. असेंबलिंग मोड में ऑटोपायलट एक एकल मॉडल उत्पन्न करता है, इसलिए हम इस मॉडल कंटेनर को अंतिम बिंदु तक तैनात कर सकते हैं। निम्नलिखित कोड देखें:

# 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, हम एक अनुमान अनुरोध भेजकर समापन बिंदु का परीक्षण कर सकते हैं और भविष्यवाणियों का निरीक्षण कर सकते हैं। निम्नलिखित चित्र इस सेटअप की वास्तुकला को दर्शाता है।

ध्यान दें कि हम कच्चे डेटा को अंतिम बिंदु पर पेलोड के रूप में भेज सकते हैं। ऑटोपायलट द्वारा उत्पन्न पहनावा मॉडल स्वचालित रूप से एल्गोरिदम मॉडल और पैकेज के साथ-साथ सभी आवश्यक फीचर-ट्रांसफॉर्म और व्युत्क्रम-लेबल ट्रांसफॉर्म चरणों को एक मॉडल में शामिल करता है।

प्रशिक्षित मॉडल को अनुमान अनुरोध भेजें

एन्सेम्बलिंग मोड का उपयोग करके प्रशिक्षित अपने मॉडल पर अनुमान भेजने के लिए निम्नलिखित कोड का उपयोग करें:

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)

एचपीओ मोड के साथ ऑटोपायलट कार्य लॉन्च करें

एचपीओ मोड में, के लिए CompletionCriteria, के अतिरिक्त MaxRuntimePerTrainingJobInSeconds और MaxAutoMLJobRuntimeInSeconds, हम यह भी निर्दिष्ट कर सकते हैं MaxCandidates ऑटोपायलट नौकरी से उत्पन्न होने वाले उम्मीदवारों की संख्या को सीमित करने के लिए। ध्यान दें कि ये वैकल्पिक पैरामीटर हैं और केवल प्रदर्शन के लिए कार्य रनटाइम को सीमित करने के लिए सेट किए गए हैं। निम्नलिखित कोड देखें:

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)

प्रशिक्षित मॉडल तैनात करें

वर्गीकरण समस्या प्रकार के लिए एचपीओ मोड में ऑटोपायलट तीन अनुमान कंटेनर उत्पन्न करता है।

पहला कंटेनर फीचर-ट्रांसफ़ॉर्म चरणों को संभालता है। इसके बाद, एल्गोरिदम कंटेनर उत्पन्न करता है 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

इस उदाहरण का पूर्ण कार्यान्वयन निम्नलिखित ज्यूपिटर में उपलब्ध है नोटबुक.

क्लीन अप

संसाधनों को साफ करने के लिए, आप बनाए गए सर्वर रहित एंडपॉइंट, एंडपॉइंट कॉन्फ़िगरेशन और मॉडल को हटा सकते हैं:

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

निष्कर्ष

इस पोस्ट में, हमने दिखाया कि कैसे हम ऑटोपायलट जनरेट किए गए मॉडल को एसेंबल और एचपीओ मोड दोनों में सर्वर रहित अनुमान समापन बिंदुओं पर तैनात कर सकते हैं। यह समाधान कच्चे डेटा से जल्दी से मॉडल तैयार करने के लिए ऑटोपायलट जैसी लागत-कुशल और पूरी तरह से प्रबंधित एमएल सेवाओं का उपयोग करने और लाभ उठाने की आपकी क्षमता को तेज कर सकता है, और फिर लागत को कम करने के लिए अंतर्निहित ऑटो स्केलिंग के साथ उन्हें पूरी तरह से प्रबंधित सर्वर रहित अनुमान समापन बिंदुओं पर तैनात कर सकता है। .

हम आपको आपके व्यावसायिक KPI के लिए प्रासंगिक डेटासेट के साथ इस समाधान को आज़माने के लिए प्रोत्साहित करते हैं। आप ज्यूपिटर नोटबुक में लागू किए गए समाधान का उल्लेख कर सकते हैं गीथहब रेपो.

अतिरिक्त संदर्भ

लेखक के बारे में

प्रवीण चमरथी अमेज़ॅन वेब सर्विसेज में एक वरिष्ठ एआई/एमएल विशेषज्ञ हैं। उन्हें एआई/एमएल और एडब्ल्यूएस से जुड़ी सभी चीजों का शौक है। वह पूरे अमेरिका में ग्राहकों को एडब्ल्यूएस पर एमएल वर्कलोड को स्केल करने, नवाचार करने और कुशलतापूर्वक संचालित करने में मदद करता है। अपने खाली समय में, प्रवीण को पढ़ना और विज्ञान-फाई फिल्में पसंद हैं।