अमेज़ॅन सेजमेकर पाइपलाइन के साथ मशीन लर्निंग वर्कफ़्लो के निर्माण के लिए सर्वोत्तम अभ्यास और डिज़ाइन पैटर्न | अमेज़न वेब सेवाएँ

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

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

सेजमेकर पाइपलाइनों के लिए सर्वोत्तम अभ्यास

इस अनुभाग में, हम कुछ सर्वोत्तम प्रथाओं पर चर्चा करते हैं जिनका सेजमेकर पाइपलाइनों का उपयोग करके वर्कफ़्लो डिज़ाइन करते समय पालन किया जा सकता है। उन्हें अपनाने से विकास प्रक्रिया में सुधार हो सकता है और सेजमेकर पाइपलाइनों के परिचालन प्रबंधन को सुव्यवस्थित किया जा सकता है।

पाइपलाइन की आलसी लोडिंग के लिए पाइपलाइन सत्र का उपयोग करें

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

from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn.processing import SKLearnProcessor
role = sagemaker.get_execution_role()
pipeline_session = PipelineSession()
sklearn_processor = SKLearnProcessor( framework_version=’0.20.0’, instance_type=’ml.m5.xlarge’, instance_count=1, base_job_name="sklearn-abalone-process", role=role, sagemaker_session=pipeline_session,
)

विकास के दौरान लागत प्रभावी और त्वरित पुनरावृत्तियों के लिए स्थानीय मोड में पाइपलाइन चलाएं

आप एक चला सकते हैं स्थानीय मोड में पाइपलाइन का उपयोग LocalPipelineSession प्रसंग। इस मोड में, सेजमेकर प्रबंधित संसाधनों के बजाय स्थानीय मशीन पर संसाधनों का उपयोग करके पाइपलाइन और नौकरियां स्थानीय रूप से चलाई जाती हैं। स्थानीय मोड डेटा के एक छोटे उपसमूह के साथ पाइपलाइन कोड पर पुनरावृति करने का एक लागत प्रभावी तरीका प्रदान करता है। पाइपलाइन का स्थानीय स्तर पर परीक्षण करने के बाद, इसका उपयोग करके इसे चलाने के लिए स्केल किया जा सकता है पाइपलाइन सत्र संदर्भ।

from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.workflow.pipeline_context import LocalPipelineSession
local_pipeline_session = LocalPipelineSession()
role = sagemaker.get_execution_role()
sklearn_processor = SKLearnProcessor( framework_version=’0.20.0’, instance_type=’ml.m5.xlarge, instance_count=1, base_job_name="sklearn-abalone-process", role=role, sagemaker_session=local_pipeline_session,
)

वर्जनिंग के माध्यम से सेजमेकर पाइपलाइन प्रबंधित करें

विकास जीवनचक्र में कलाकृतियों और पाइपलाइन परिभाषाओं का संस्करणीकरण एक सामान्य आवश्यकता है। आप एक अद्वितीय उपसर्ग या प्रत्यय के साथ पाइपलाइन ऑब्जेक्ट का नामकरण करके पाइपलाइन के कई संस्करण बना सकते हैं, सबसे आम टाइमस्टैम्प है, जैसा कि निम्नलिखित कोड में दिखाया गया है:

from sagemaker.workflow.pipeline_context import PipelineSession
import time current_time = time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
pipeline_name = "pipeline_" + current_time
pipeline_session = PipelineSession()
pipeline = Pipeline( name=pipeline_name, steps=[step_process, step_train, step_eval, step_cond], sagemaker_session=pipeline_session,
)

सेजमेकर प्रयोगों के साथ एकीकृत करके सेजमेकर पाइपलाइन को व्यवस्थित और ट्रैक करें

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

Pipeline( name="MyPipeline", parameters=[...], pipeline_experiment_config=PipelineExperimentConfig( experiment_name = ExecutionVariables.PIPELINE_NAME, trial_name = ExecutionVariables.PIPELINE_EXECUTION_ID ), steps=[...]
)

एक निजी वीपीसी के भीतर सेजमेकर पाइपलाइनों को सुरक्षित रूप से चलाएं

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

# IAM Policy to enforce execution within a private VPC { "Action": [ "sagemaker:CreateProcessingJob", "sagemaker:CreateTrainingJob", "sagemaker:CreateModel" ], "Resource": "*", "Effect": "Deny", "Condition": { "Null": { "sagemaker:VpcSubnets": "true" } }
} # IAM Policy to enforce execution in network isolation mode
{ "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "sagemaker:Create*" ], "Resource": "*", "Condition": { "StringNotEqualsIfExists": { "sagemaker:NetworkIsolation": "true" } } } ]
}

इन सुरक्षा नियंत्रणों के साथ पाइपलाइन कार्यान्वयन के उदाहरण के लिए, देखें एक सुरक्षित वातावरण में अमेज़ॅन सेजमेकर के साथ ऑर्केस्ट्रेटिंग नौकरियां, मॉडल पंजीकरण और निरंतर तैनाती.

टैग का उपयोग करके पाइपलाइन चलाने की लागत की निगरानी करें

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

sklearn_processor = SKLearnProcessor( framework_version=’0.20.0’, instance_type=’ml.m5.xlarge, instance_count=1, base_job_name="sklearn-abalone-process", role=role, tags=[{'Key':'pipeline-cost-tag', 'Value':'<<tag_parameter>>'}]
) step_process = ProcessingStep( name="AbaloneProcess", processor=sklearn_processor, ...
)

लागत एक्सप्लोरर से, अब आप टैग द्वारा फ़िल्टर की गई लागत प्राप्त कर सकते हैं:

response = client.get_cost_and_usage( TimePeriod={ 'Start': '2023-07-01', 'End': '2023-07-15' }, Metrics=['BLENDED_COST','USAGE_QUANTITY','UNBLENDED_COST'], Granularity='MONTHLY', Filter={ 'Dimensions': { 'Key':'USAGE_TYPE', 'Values': [ ‘SageMaker:Pipeline’ ] }, 'Tags': { 'Key': 'keyName', 'Values': [ 'keyValue', ] } }
)

कुछ सामान्य परिदृश्यों के लिए डिज़ाइन पैटर्न

इस अनुभाग में, हम सेजमेकर पाइपलाइनों के साथ कुछ सामान्य उपयोग के मामलों के लिए डिज़ाइन पैटर्न पर चर्चा करते हैं।

लैम्ब्डा चरण का उपयोग करके एक हल्का पायथन फ़ंक्शन चलाएँ

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

%%writefile lambdafunc.py import json def lambda_handler(event, context): str1 = event["str1"] str2 = event["str2"] str3 = str1 + str2 return { "str3": str3 }

लैम्ब्डा फ़ंक्शन का उपयोग करके बनाएं सेजमेकर पायथन एसडीके का लैम्ब्डा हेल्पर:

from sagemaker.lambda_helper import Lambda def create_lambda(function_name, script, handler): response = Lambda( function_name=function_name, execution_role_arn=role, script= script, handler=handler, timeout=600, memory_size=10240, ).upsert() function_arn = response['FunctionArn'] return function_arn fn_arn = create_Lambda("func", "lambdafunc.py", handler = "lambdafunc.lambda_handler")

लैम्ब्डा चरण को कॉल करें:

from sagemaker.lambda_helper import Lambda
from sagemaker.workflow.lambda_step import ( LambdaStep, LambdaOutput, LambdaOutputTypeEnum
) str3 = LambdaOutput(output_name="str3", output_type=LambdaOutputTypeEnum.String) # Lambda Step
step_lambda1 = LambdaStep( name="LambdaStep1", lambda_func=Lambda( function_arn=fn_arn ), inputs={ "str1": "Hello", "str2": " World" }, outputs=[str3],
)

चरणों के बीच डेटा पास करें

पाइपलाइन चरण के लिए इनपुट डेटा या तो एक सुलभ डेटा स्थान है या पाइपलाइन में पिछले चरणों में से किसी एक द्वारा उत्पन्न डेटा है। आप यह जानकारी इस प्रकार प्रदान कर सकते हैं ProcessingInput पैरामीटर. आइए कुछ परिदृश्यों पर नजर डालें कि आप प्रोसेसिंगइनपुट का उपयोग कैसे कर सकते हैं।

परिदृश्य 1: लैम्ब्डा चरण के आउटपुट (आदिम डेटा प्रकार) को प्रसंस्करण चरण में पास करें

आदिम डेटा प्रकार स्ट्रिंग, पूर्णांक, बूलियन और फ्लोट जैसे स्केलर डेटा प्रकारों को संदर्भित करते हैं।

निम्नलिखित कोड स्निपेट एक लैम्ब्डा फ़ंक्शन को परिभाषित करता है जो आदिम डेटा प्रकारों के साथ चर का एक शब्दकोश लौटाता है। सेजमेकर पाइपलाइन के भीतर लैम्ब्डा चरण से बुलाए जाने पर आपका लैम्ब्डा फ़ंक्शन कोड कुंजी-मूल्य जोड़े का एक JSON लौटाएगा।

def handler(event, context): ... return { "output1": "string_value", "output2": 1, "output3": True, "output4": 2.0, }

पाइपलाइन परिभाषा में, आप फिर सेजमेकर पाइपलाइन पैरामीटर को परिभाषित कर सकते हैं जो एक विशिष्ट डेटा प्रकार के होते हैं और वेरिएबल को लैम्ब्डा फ़ंक्शन के आउटपुट पर सेट कर सकते हैं:

from sagemaker.workflow.lambda_step import ( LambdaStep, LambdaOutput, LambdaOutputTypeEnum
)
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn.processing import SKLearnProcessor role = sagemaker.get_execution_role()
pipeline_session = PipelineSession() # 1. Define the output params of the Lambda Step str_outputParam = LambdaOutput(output_name="output1", output_type=LambdaOutputTypeEnum.String)
int_outputParam = LambdaOutput(output_name"output2", output_type=LambdaOutputTypeEnum.Integer)
bool_outputParam = LambdaOutput(output_name"output3", output_type=LambdaOutputTypeEnum.Boolean)
float_outputParam = LambdaOutput(output_name"output4", output_type=LambdaOutputTypeEnum.Float) # 2. Lambda step invoking the lambda function and returns the Output step_lambda = LambdaStep( name="MyLambdaStep", lambda_func=Lambda( function_arn="arn:aws:lambda:us-west-2:123456789012:function:sagemaker_test_lambda", session=PipelineSession(), ), inputs={"arg1": "foo", "arg2": "foo1"}, outputs=[ str_outputParam, int_outputParam, bool_outputParam, float_outputParam ],
) # 3. Extract the output of the Lambda str_outputParam = step_lambda.properties.Outputs["output1"] # 4. Use it in a subsequent step. For ex. Processing step sklearn_processor = SKLearnProcessor( framework_version="0.23-1", instance_type="ml.m5.xlarge", instance_count=1, sagemaker_session=pipeline_session, role=role
) processor_args = sklearn_processor.run( code="code/preprocess.py", #python script to run arguments=["--input-args", str_outputParam]
) step_process = ProcessingStep( name="processstep1", step_args=processor_args,
)

परिदृश्य 2: लैम्ब्डा चरण के आउटपुट (गैर-आदिम डेटा प्रकार) को प्रसंस्करण चरण में पास करें

गैर-आदिम डेटा प्रकार गैर-स्केलर डेटा प्रकारों को संदर्भित करते हैं (उदाहरण के लिए, NamedTuple). आपके पास एक परिदृश्य हो सकता है जब आपको लैम्ब्डा फ़ंक्शन से एक गैर-आदिम डेटा प्रकार वापस करना होगा। ऐसा करने के लिए, आपको अपने गैर-आदिम डेटा प्रकार को एक स्ट्रिंग में बदलना होगा:

# Lambda function code returning a non primitive data type from collections import namedtuple def lambda_handler(event, context): Outputs = namedtuple("Outputs", "sample_output") named_tuple = Outputs( [ {'output1': 1, 'output2': 2}, {'output3': 'foo', 'output4': 'foo1'} ] )
return{ "named_tuple_string": str(named_tuple)
}

#Pipeline step that uses the Lambda output as a “Parameter Input” output_ref = step_lambda.properties.Outputs["named_tuple_string"]

फिर आप इस स्ट्रिंग को पाइपलाइन में अगले चरण के इनपुट के रूप में उपयोग कर सकते हैं। कोड में नामित टुपल का उपयोग करने के लिए, उपयोग करें eval() स्ट्रिंग में पायथन अभिव्यक्ति को पार्स करने के लिए:

# Decipher the string in your processing logic code import argparse
from collections import namedtuple Outputs = namedtuple("Outputs", "sample_output") if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--named_tuple_string", type=str, required=True) args = parser.parse_args() #use eval to obtain the named tuple from the string named_tuple = eval(args.named_tuple_string)

परिदृश्य 3: किसी चरण के आउटपुट को प्रॉपर्टी फ़ाइल के माध्यम से पास करें

आप प्रोसेसिंग चरण के आउटपुट को इसमें भी संग्रहीत कर सकते हैं संपत्ति JSON फ़ाइल ए में डाउनस्ट्रीम खपत के लिए ConditionStep या एक और ProcessingStep। आप उपयोग कर सकते हैं JSONGet फ़ंक्शन ए पूछने के लिए संपत्ति फ़ाइल। निम्नलिखित कोड देखें:

# 1. Define a Processor with a ProcessingOutput
sklearn_processor = SKLearnProcessor( framework_version="0.23-1", instance_type="ml.m5.xlarge", instance_count=1, base_job_name="sklearn-abalone-preprocess", sagemaker_session=session, role=sagemaker.get_execution_role(),
) step_args = sklearn_processor.run( outputs=[ ProcessingOutput( output_name="hyperparam", source="/opt/ml/processing/evaluation" ), ], code="./local/preprocess.py", arguments=["--input-data", "s3://my-input"],
) # 2. Define a PropertyFile where the output_name matches that with the one used in the Processor

hyperparam_report = PropertyFile( name="AbaloneHyperparamReport", output_name="hyperparam", path="hyperparam.json",
)

आइए मान लें कि संपत्ति फ़ाइल की सामग्री निम्नलिखित थी:

{ "hyperparam": { "eta": { "value": 0.6 } }
}

इस मामले में, इसे एक विशिष्ट मान के लिए क्वेरी किया जा सकता है और JsonGet फ़ंक्शन का उपयोग करके बाद के चरणों में उपयोग किया जा सकता है:

# 3. Query the property file
eta = JsonGet( step_name=step_process.name, property_file=hyperparam_report, json_path="hyperparam.eta.value",
)

पाइपलाइन परिभाषा में एक वेरिएबल को पैरामीटराइज़ करें

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

# define the variable to store the s3 URI
s3_location = Join( on="/", values=[ "s3:/", ParameterString( name="MyBucket", default_value="" ), "training", ExecutionVariables.PIPELINE_EXECUTION_ID ]
) # define the processing step
sklearn_processor = SKLearnProcessor( framework_version="1.2-1", instance_type="ml.m5.xlarge", instance_count=processing_instance_count, base_job_name=f"{base_job_prefix}/sklearn-abalone-preprocess", sagemaker_session=pipeline_session, role=role,
) # use the s3uri as the output location in processing step
processor_run_args = sklearn_processor.run( outputs=[ ProcessingOutput( output_name="train", source="/opt/ml/processing/train", destination=s3_location, ), ], code="code/preprocess.py"
) step_process = ProcessingStep( name="PreprocessingJob”, step_args=processor_run_args,
)

किसी पुनरावर्तनीय पर समानांतर कोड चलाएँ

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

परिदृश्य 1: डेटा के विभिन्न भागों पर प्रसंस्करण तर्क लागू करें

आप एक प्रसंस्करण कार्य को कई उदाहरणों के साथ चला सकते हैं (सेटिंग द्वारा)। instance_count 1) से अधिक मान पर। यह Amazon S3 से इनपुट डेटा को सभी प्रोसेसिंग इंस्टेंसेस में वितरित करता है। फिर आप आइटम की सूची में इंस्टेंस संख्या और संबंधित तत्व के आधार पर डेटा के एक विशिष्ट हिस्से पर काम करने के लिए एक स्क्रिप्ट (process.py) का उपयोग कर सकते हैं। Process.py में प्रोग्रामिंग लॉजिक को इस तरह लिखा जा सकता है कि एक अलग मॉड्यूल या कोड का टुकड़ा उन वस्तुओं की सूची के आधार पर चलता है जिन्हें वह संसाधित करता है। निम्नलिखित उदाहरण एक प्रोसेसर को परिभाषित करता है जिसका उपयोग प्रोसेसिंगस्टेप में किया जा सकता है:

sklearn_processor = FrameworkProcessor( estimator_cls=sagemaker.sklearn.estimator.SKLearn, framework_version="0.23-1", instance_type='ml.m5.4xlarge', instance_count=4, #number of parallel executions / instances base_job_name="parallel-step", sagemaker_session=session, role=role,
) step_args = sklearn_processor.run( code='process.py', arguments=[ "--items", list_of_items, #data structure containing a list of items inputs=[ ProcessingInput(source="s3://sagemaker-us-east-1-xxxxxxxxxxxx/abalone/abalone-dataset.csv", destination="/opt/ml/processing/input" ) ], ]
)

परिदृश्य 2: चरणों का क्रम चलाएँ

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

import boto3
def lambda_handler(event, context): items = [1, 2] #sagemaker client sm_client = boto3.client("sagemaker") #name of the pipeline that needs to be triggered. #if there are multiple, you can fetch available pipelines using boto3 api #and trigger the appropriate one based on your logic. pipeline_name = 'child-pipeline-1' #trigger pipeline for every item response_ppl = sm_client.start_pipeline_execution( PipelineName=pipeline_name, PipelineExecutionDisplayName=pipeline_name+'-item-%d' %(s), ) pipeline_name = 'child-pipeline-2' response_ppl = sm_client.start_pipeline_execution( PipelineName=pipeline_name, PipelineExecutionDisplayName=pipeline_name+'-item-%d' %(s), )
return

निष्कर्ष

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

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

पिनाक पाणिग्रही AWS पर रणनीतिक व्यावसायिक समस्याओं को हल करने के लिए मशीन लर्निंग संचालित समाधान बनाने के लिए ग्राहकों के साथ काम करता है। जब वह मशीन लर्निंग में व्यस्त नहीं होता, तो उसे सैर करते, किताब पढ़ते या खेल देखते हुए पाया जा सकता है।

मीनाक्षीसुंदरम थंडावरायण AWS के लिए AI / ML विशेषज्ञ के रूप में काम करता है। उन्हें मानव-केंद्रित डेटा और एनालिटिक्स अनुभवों को डिजाइन करने, बनाने और बढ़ावा देने का जुनून है। मीना एडब्ल्यूएस के रणनीतिक ग्राहकों के लिए औसत दर्जे का, प्रतिस्पर्धी लाभ प्रदान करने वाली स्थायी प्रणाली विकसित करने पर ध्यान केंद्रित करती है। मीना एक कनेक्टर, डिजाइन थिंकर हैं, और नवाचार, ऊष्मायन और लोकतांत्रीकरण के माध्यम से काम करने के नए तरीकों से व्यवसाय को चलाने का प्रयास करती हैं।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. ऑटोमोटिव/ईवीएस, कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• चार्टप्राइम. चार्टप्राइम के साथ अपने ट्रेडिंग गेम को उन्नत करें। यहां पहुंचें।
• BlockOffsets. पर्यावरणीय ऑफसेट स्वामित्व का आधुनिकीकरण। यहां पहुंचें।
• स्रोत: https://aws.amazon.com/blogs/machine-learning/best-practices-and-design-patterns-for-building-machine-learning-workflows-with-amazon-sagemaker-pipelines/