Amazon SageMaker मॉडल रजिस्ट्री का उपयोग करके एक क्रॉस-खाता MLOps वर्कफ़्लो बनाएँ

किसी भी सॉफ़्टवेयर डेवलपमेंट वर्कफ़्लो को प्रभावी ढंग से स्केल करने के लिए एक अच्छी तरह से डिज़ाइन किया गया CI/CD पाइपलाइन आवश्यक है। उत्पादन सीआई/सीडी पाइपलाइनों को डिजाइन करते समय, एडब्ल्यूएस संसाधनों को अलग करने, सुरक्षा खतरों को रोकने और बिलिंग को सरल बनाने के लिए कई खातों का लाभ उठाने की सिफारिश करता है- और डेटा साइंस पाइपलाइन अलग नहीं हैं। AWS में, हम MLOps कार्यप्रवाह को सरल बनाने के लिए निरंतर नवप्रवर्तन कर रहे हैं।

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

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

निम्नलिखित आरेख हमारे साझा मॉडल रजिस्ट्री आर्किटेक्चर को दिखाता है।

पूर्ववर्ती वास्तु शास्त्र में ध्यान देने योग्य कुछ बातें:

निम्नलिखित चरण आरेख के अनुरूप हैं:

1. एक डेटा वैज्ञानिक डेटा विज्ञान खाते से एक मॉडल को साझा सेवाओं SageMaker मॉडल रजिस्ट्री में एक में पंजीकृत करता है PendingManualApproval राज्य। साझा सेवाओं के खाते में मॉडल आर्टिफैक्ट बनाया गया है अमेज़न सरल भंडारण सेवा (अमेज़न S3) बाल्टी।
2. एक नए मॉडल संस्करण पंजीकरण पर, मेट्रिक्स के आधार पर मॉडल को स्वीकृत करने के अधिकार वाले किसी व्यक्ति को मॉडल को स्वीकार या अस्वीकार करना चाहिए।
3. मॉडल स्वीकृत होने के बाद, परिनियोजन खाते में CI/CD पाइपलाइन है लगाने के लिए प्रेरित किया QA खाते में अद्यतन मॉडल विवरण और QA के रूप में चरण को अद्यतन करें।
4. परीक्षण प्रक्रिया पास करने पर, आप या तो अपनी सीआई/सीडी प्रक्रिया के भीतर एक मैन्युअल अनुमोदन चरण चुन सकते हैं या अपनी सीआई/सीडी पाइपलाइन को सीधे उत्पादन के लिए मॉडल को परिनियोजित कर सकते हैं और स्टेज को उत्पाद के रूप में अपडेट कर सकते हैं।
5. उत्पादन वातावरण स्वीकृत मॉडल और कोड को संदर्भित करता है, शायद ऐसा कर रहा है उत्पादन में ए / बी परीक्षण. ऑडिट या मॉडल के साथ किसी भी समस्या के मामले में, आप इसका उपयोग कर सकते हैं अमेज़ॅन सैजमेकर एमएल वंश ट्रैकिंग. यह डेटा तैयार करने से लेकर मॉडल परिनियोजन तक मशीन लर्निंग (ML) वर्कफ़्लो के चरणों के बारे में जानकारी बनाता और संग्रहीत करता है। ट्रैकिंग जानकारी के साथ, आप वर्कफ़्लो चरणों को पुन: उत्पन्न कर सकते हैं, मॉडल और डेटासेट वंश को ट्रैक कर सकते हैं और मॉडल शासन और ऑडिट मानकों को स्थापित कर सकते हैं।

पूरी प्रक्रिया के दौरान, साझा मॉडल रजिस्ट्री पुराने मॉडल संस्करणों को बनाए रखती है। यह टीम को परिवर्तनों को वापस लाने या यहां तक ​​कि होस्ट करने की अनुमति देता है उत्पादन वेरिएंट.

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

सुनिश्चित करें कि आपके पास निम्नलिखित पूर्वापेक्षाएँ हैं:

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

क्रॉस-खाता नीतियों को परिभाषित करें

कम से कम विशेषाधिकार के सिद्धांत का पालन करते हुए, पहले हमें अन्य खातों से एक्सेस प्रदान करने के लिए साझा सेवाओं के संसाधनों में क्रॉस-खाता संसाधन नीतियों को जोड़ने की आवश्यकता है।

क्योंकि मॉडल कलाकृतियों को साझा सेवा खाते के S3 बकेट में संग्रहीत किया जाता है, इसलिए डेटा विज्ञान खाते को Amazon S3 में प्रशिक्षित मॉडल पुश करने के लिए Amazon S3 पढ़ने/लिखने की आवश्यकता होती है। निम्नलिखित कोड इस नीति का वर्णन करता है, लेकिन इसे अभी तक साझा सेवा खाते में न जोड़ें:

#Data Science account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        }, 
        "Action": [ 
            's3:PutObject', 
            's3:PutObjectAcl',
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read/write
        'Resource': 'arn:aws:s3:::/*'
    }]
}

परिनियोजन खाते को केवल S3 बकेट तक पठन पहुंच प्रदान करने की आवश्यकता है, ताकि वह SageMaker समापन बिंदुओं पर परिनियोजित करने के लिए मॉडल कलाकृतियों का उपयोग कर सके। हमें निम्नलिखित नीति को साझा सेवाओं S3 बकेट में संलग्न करने की आवश्यकता है:

#Deployment account's policy to access Shared Services' S3 bucket
 {
    'Version': '2012-10-17',
    'Statement': [{
        'Sid': 'AddPerm',
        'Effect': 'Allow',
        'Principal': {
            'AWS': 'arn:aws:iam:::root'
        },
        'Action': [ 
            's3:GetObject', 
            's3:GetObjectVersion'
        ], #read
        'Resource': 'arn:aws:s3:::/*'
    }]
}

हम निम्नलिखित अंतिम नीति प्राप्त करने के लिए दोनों नीतियों को जोड़ते हैं। उपयुक्त खाता आईडी को बदलने के बाद साझा सेवा खाते में यह नीति बनाएं:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Sid": "AddPerm",
    "Effect": "Allow",
    "Principal": {
      "AWS": "arn:aws:iam:::root"    
    },
    "Action": [
      "s3:PutObject",
      "s3:PutObjectAcl",
      "s3:GetObject",
      "s3:GetObjectVersion"    ],
    "Resource": "arn:aws:s3:::/*"  
    },
    {
      "Sid": "AddPermDeployment",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "s3:GetObject",
        "s3:GetObjectVersion"      ], 
      "Resource": "arn:aws:s3:::/*"    
    }
  ]
}

एक अलग खाते में बनाए गए मॉडल को तैनात करने में सक्षम होने के लिए, उपयोगकर्ता के पास एक ऐसी भूमिका होनी चाहिए जिसकी SageMaker क्रियाओं तक पहुंच हो, जैसे कि एक भूमिका AmazonSageMakerFullAccess प्रबंधित नीति। को देखें किसी भिन्न खाते से मॉडल संस्करण परिनियोजित करें अतिरिक्त जानकारी के लिए।

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

• साझा_सेवा_खाता_आईडी - वह खाता जहां मॉडल रजिस्ट्री है और जहां हम चाहते हैं कि मॉडल हो
• डेटा_साइंस_अकाउंट_आईडी - वह खाता जहां हम प्रशिक्षण देंगे और इसलिए वास्तविक मॉडल विरूपण साक्ष्य तैयार करेंगे
• तैनाती_खाता_आईडी - वह खाता जहां हम इस मॉडल के लिए समापन बिंदु को होस्ट करना चाहते हैं

पहले हमें यह सुनिश्चित करने की आवश्यकता है कि मॉडल पैकेज समूह मौजूद हैं। आप नीचे दिए गए उदाहरण के अनुसार Boto3 API का उपयोग कर सकते हैं, या आप इसका उपयोग कर सकते हैं एडब्ल्यूएस प्रबंधन कंसोल मॉडल पैकेज बनाने के लिए। को देखें मॉडल पैकेज समूह बनाएँ अधिक जानकारी के लिए। यह मानता है कि आपके पास Boto3 स्थापित है।

model_package_group_name = "cross-account-example-model"
sm_client = boto3.Session().client("sagemaker")

create_model_package_group_response = sm_client.create_model_package_group(
    ModelPackageGroupName=model_package_group_name,
    ModelPackageGroupDescription="Cross account model package group",
    Tags=[
          {
              'Key': 'Name',
              'Value': 'cross_account_test'
          },
      ]

)

print('ModelPackageGroup Arn : {}'.format(create_model_package_group_response['ModelPackageGroupArn']))

इस मॉडल पैकेज समूह की अनुमतियों के लिए, आप निम्न कोड जैसा JSON दस्तावेज़ बना सकते हैं। वास्तविक खाता आईडी और मॉडल पैकेज समूह नाम को अपने मूल्यों से बदलें।

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AddPermModelPackageGroupCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackageGroup"      
        ],
      "Resource": "arn:aws:sagemaker:::model-package-group/"    
    },
    {
      "Sid": "AddPermModelPackageVersionCrossAccount",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam:::root"      
      },
      "Action": [
        "sagemaker:DescribeModelPackage",
        "sagemaker:ListModelPackages",
        "sagemaker:UpdateModelPackage",
        "sagemaker:CreateModelPackage",
        "sagemaker:CreateModel"      
      ],
      "Resource": "arn:aws:sagemaker:::model-package//*"    
    }
  ]
}

अंत में, नीति को मॉडल पैकेज समूह पर लागू करें। आप इस नीति को कंसोल के माध्यम से पैकेज समूह से संबद्ध नहीं कर सकते। आपको एसडीके की जरूरत है या AWS कमांड लाइन इंटरफ़ेस (एडब्ल्यूएस सीएलआई) एक्सेस। उदाहरण के लिए, निम्न कोड Boto3 का उपयोग करता है:

# Convert the policy from JSON dict to string
model_package_group_policy = dict( )
model_package_group_policy = json.dumps(model_package_group_policy)

# Set the new policy
sm_client = boto3.Session().client("sagemaker")
response = sm_client.put_model_package_group_policy(
    ModelPackageGroupName = model_package_group_name,
    ResourcePolicy = model_package_group_policy)

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

नीति और अनुमतियाँ इस पैटर्न का पालन करती हैं:

• Amazon S3 नीति में निर्दिष्ट किया गया है shared_services_account डेटा साइंस अकाउंट और डिप्लॉयमेंट अकाउंट को अनुमति देता है
• केएमएस कुंजी नीति में निर्दिष्ट shared_services_account डेटा साइंस अकाउंट और डिप्लॉयमेंट अकाउंट को अनुमति देता है

हमें यह सुनिश्चित करने की आवश्यकता है कि साझा सेवाओं के खाते और परिनियोजन खाते के पास मॉडल के प्रशिक्षण के लिए उपयोग की जाने वाली डॉकर छवियों तक पहुंच हो। ये छवियां आम तौर पर AWS खातों में होस्ट की जाती हैं, और यदि आपके पास पहले से पहुंच नहीं है, तो आपका खाता व्यवस्थापक आपको पहुंच प्राप्त करने में सहायता कर सकता है। इस पोस्ट के लिए, हम मॉडल को प्रशिक्षित करने के बाद कोई कस्टम डॉकर चित्र नहीं बनाते हैं और इसलिए हमें छवियों के लिए किसी विशिष्ट Amazon ECR नीति की आवश्यकता नहीं है।

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

पहली इनलाइन नीति किसी भूमिका को मॉडल आर्टिफैक्ट वाले साझा सेवा खाते में Amazon S3 संसाधन तक पहुंचने की अनुमति देती है। S3 बकेट और अपने मॉडल का नाम प्रदान करें:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::/sagemaker//output/model.tar.gz"
        }
    ]
}

दूसरी इनलाइन नीति एक भूमिका की अनुमति देती है, जिसे हम बाद में साझा सेवाओं के खाते में KMS कुंजी का उपयोग करने के लिए बनाते हैं। साझा सेवाओं के खाते के लिए खाता आईडी और KMS कुंजी आईडी निर्दिष्ट करें:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "AllowUseOfTheKey",
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": [
                "arn:aws:kms:us-east-1::key/{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}"
            ]
        }
    ]
}

अंत में, हमें चाहिए IAM भूमिका बनाएँ सेजमेकर के लिए। इस भूमिका की है AmazonSageMakerFullAccess नीति संलग्न। फिर हम इन दो इनलाइन नीतियों को हमारे द्वारा बनाई गई भूमिका से जोड़ते हैं। यदि आप मौजूदा SageMaker निष्पादन भूमिका का उपयोग कर रहे हैं, तो इन दो नीतियों को उस भूमिका में संलग्न करें। निर्देशों के लिए, देखें भूमिकाएँ बनाना और नीतियां संलग्न करना (कंसोल).

अब जब हमने प्रत्येक खाते की नीतियों को परिभाषित कर लिया है, आइए इसे क्रियान्वित करने के लिए एक उदाहरण का उपयोग करें।

SageMaker पाइपलाइन का उपयोग करके एक मॉडल बनाएँ और प्रशिक्षित करें

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

हम एक बनाते हैं SKLearnProcessor इस प्रीप्रोसेसिंग स्क्रिप्ट को चलाने के लिए ऑब्जेक्ट। SageMaker पाइपलाइन में, हम एक प्रोसेसिंग चरण (ProcessingStep) का उपयोग करके प्रोसेसिंग कोड चलाने के लिए SKLearnProcessor. इस प्रोसेसिंग कोड को कॉल किया जाता है जब SageMaker पाइपलाइन को इनिशियलाइज़ किया जाता है। कोड बना रहा है SKLearnProcessor और ProcessingStep निम्नलिखित कोड में दिखाया गया है। ध्यान दें कि इस खंड के सभी कोड डेटा साइंस खाते में चलाए जाते हैं।

# Useful SageMaker variables - Create a Pipeline session which will lazy init resources
session = PipelineSession()

framework_version = "0.23-1"

# Create SKlearn processor object,
# The object contains information about what instance type to use, the IAM role to use etc.
# A managed processor comes with a preconfigured container, so only specifying version is required.
sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    role=role,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-processing-job",
    sagemaker_session=session
)

# Use the sklearn_processor in a SageMaker pipelines ProcessingStep
step_preprocess_data = ProcessingStep(
    name="Preprocess-California-Housing-Data",
    processor=sklearn_processor,
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="preprocess.py",
)

मॉडल को Amazon S3 में संग्रहीत करते समय उसे एन्क्रिप्ट करने के लिए हमें एक कस्टम KMS कुंजी की आवश्यकता होती है। निम्नलिखित कोड देखें:

kms_client = boto3.client('kms')
response = kms_client.describe_key(
    KeyId='alias/sagemaker/outkey',
)
key_id = response['KeyMetadata']['KeyId']

मॉडल को प्रशिक्षित करने के लिए, हम एक TensorFlow अनुमानक वस्तु बनाते हैं। हम इसे अपने प्रशिक्षण स्क्रिप्ट के साथ KMS कुंजी आईडी पास करते हैं train.py, प्रशिक्षण उदाहरण प्रकार और गिनती। हम एक भी बनाते हैं TrainingStep हमारी पाइपलाइन में जोड़ने के लिए, और इसमें TensorFlow अनुमानक जोड़ें। निम्नलिखित कोड देखें:

model_path = f"s3://{bucket}/{prefix}/model/"

hyperparameters = {"epochs": training_epochs}
tensorflow_version = "2.4.1"
python_version = "py37"

tf2_estimator = TensorFlow(
    source_dir="code",
    entry_point="train.py",
    instance_type=training_instance_type,
    instance_count=1,
    framework_version=tensorflow_version,
    role=role,
    base_job_name="tf2-california-housing-train",
    output_path=model_path,
    output_kms_key=key_id,
    hyperparameters=hyperparameters,
    py_version=python_version,
    sagemaker_session=session
)

# Use the tf2_estimator in a SageMaker pipelines ProcessingStep.
# NOTE how the input to the training job directly references the output of the previous step.
step_train_model = TrainingStep(
    name="Train-California-Housing-Model",
    estimator=tf2_estimator,
    inputs={
        "train": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "test": TrainingInput(
            s3_data=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    },
)

प्रशिक्षण के अलावा, हमें मॉडल मूल्यांकन करने की आवश्यकता है, जिसके लिए हम इस उदाहरण में मीट्रिक के रूप में माध्य चुकता त्रुटि (MSE) का उपयोग करते हैं। पहले की नोटबुक भी उत्पन्न करता है evaluate.py, जिसका उपयोग हम MSE का उपयोग करके अपने मॉडल का मूल्यांकन करने के लिए करते हैं। हम एक भी बनाते हैं ProcessingStep a का उपयोग करके मॉडल मूल्यांकन स्क्रिप्ट को प्रारंभ करने के लिए SKLearnProcessor वस्तु। निम्न कोड इस चरण को बनाता है:

from sagemaker.workflow.properties import PropertyFile

# Create SKLearnProcessor object.
# The object contains information about what container to use, what instance type etc.
evaluate_model_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=1,
    base_job_name="tf2-california-housing-evaluate",
    role=role,
    sagemaker_session=session
)

# Create a PropertyFile
# A PropertyFile is used to be able to reference outputs from a processing step, for instance to use in a condition step.
# For more information, visit https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html
evaluation_report = PropertyFile(
    name="EvaluationReport", output_name="evaluation", path="evaluation.json"
)

# Use the evaluate_model_processor in a SageMaker pipelines ProcessingStep.
step_evaluate_model = ProcessingStep(
    name="Evaluate-California-Housing-Model",
    processor=evaluate_model_processor,
    inputs=[
        ProcessingInput(
            source=step_train_model.properties.ModelArtifacts.S3ModelArtifacts,
            destination="/opt/ml/processing/model",
        ),
        ProcessingInput(
            source=step_preprocess_data.properties.ProcessingOutputConfig.Outputs[
                "test"
            ].S3Output.S3Uri,
            destination="/opt/ml/processing/test",
        ),
    ],
    outputs=[
        ProcessingOutput(output_name="evaluation", source="/opt/ml/processing/evaluation"),
    ],
    code="evaluate.py",
    property_files=[evaluation_report],
)

मॉडल मूल्यांकन के बाद, हमें अपने मॉडल को मॉडल रजिस्ट्री के साथ पंजीकृत करने के लिए भी एक चरण की आवश्यकता है, यदि मॉडल प्रदर्शन आवश्यकताओं को पूरा करता है। यह निम्नलिखित कोड में प्रयोग करके दिखाया गया है RegisterModel कदम। यहां हमें उस मॉडल पैकेज को निर्दिष्ट करने की आवश्यकता है जिसे हमने साझा सेवाओं के खाते में घोषित किया था। क्षेत्र, खाता और मॉडल पैकेज को अपने मूल्यों से बदलें। यहाँ प्रयुक्त मॉडल का नाम है modeltest, लेकिन आप अपनी पसंद के किसी भी नाम का उपयोग कर सकते हैं।

# Create ModelMetrics object using the evaluation report from the evaluation step
# A ModelMetrics object contains metrics captured from a model.
model_metrics = ModelMetrics(
    model_statistics=MetricsSource(
        s3_uri=evaluation_s3_uri,
        content_type="application/json",
    )
)

# Create a RegisterModel step, which registers the model with SageMaker Model Registry.
model = Model(
    image_uri=tf2_estimator.training_image_uri(),
    model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir=tf2_estimator.source_dir,
    entry_point=tf2_estimator.entry_point,
    role=role_arn,
    sagemaker_session=session
)

model_registry_args = model.register(
    content_types=['text/csv'],
    response_types=['application/json'],
    inference_instances=['ml.t2.medium', 'ml.m5.xlarge'],
    transform_instances=['ml.m5.xlarge'],
    model_package_group_name=model_package_group_name,
    approval_status='PendingManualApproval',
    model_metrics=model_metrics
)

 step_register_model= ModelStep(
    name='RegisterModel',
    step_args=model_registry_args
)

हमें मॉडल आर्टिफैक्ट बनाने की भी आवश्यकता है ताकि इसे तैनात किया जा सके (दूसरे खाते का उपयोग करके)। मॉडल बनाने के लिए, हम एक बनाते हैं CreateModelStep, जैसा कि निम्नलिखित कोड में दिखाया गया है:

from sagemaker.inputs import CreateModelInput 
from sagemaker.workflow.model_step import ModelStep 
step_create_model = ModelStep( 
    name="Create-California-Housing-Model", 
    step_args=model.create(instance_type="ml.m5.large",accelerator_type="ml.eia1.medium"),
 )

पाइपलाइन में शर्तों को जोड़ने का कार्य किया जाता है a ConditionStep. इस मामले में, हम केवल नए मॉडल संस्करण को मॉडल रजिस्ट्री के साथ पंजीकृत करना चाहते हैं यदि नया मॉडल सटीकता की स्थिति को पूरा करता है। निम्नलिखित कोड देखें:

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import (
    ConditionStep,
    JsonGet,
)

# Create accuracy condition to ensure the model meets performance requirements.
# Models with a test accuracy lower than the condition will not be registered with the model registry.
cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step=step_evaluate_model,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",
    ),
    right=accuracy_mse_threshold,
)

# Create a SageMaker Pipelines ConditionStep, using the preceding condition.
# Enter the steps to perform if the condition returns True / False.
step_cond = ConditionStep(
    name="MSE-Lower-Than-Threshold-Condition",
    conditions=[cond_lte],
    if_steps=[step_register_model, step_create_model],
    else_steps=[step_higher_mse_send_email_lambda],
)

अंत में, हम पाइपलाइन के सभी चरणों को ऑर्केस्ट्रेट करना चाहते हैं ताकि पाइपलाइन को इनिशियलाइज़ किया जा सके:

from sagemaker.workflow.pipeline import Pipeline

# Create a SageMaker Pipeline.
# Each parameter for the pipeline must be set as a parameter explicitly when the pipeline is created.
# Also pass in each of the preceding steps.
# Note that the order of execution is determined from each step's dependencies on other steps,
# not on the order they are passed in.
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        processing_instance_type,
        training_instance_type,
        input_data,
        training_epochs,
        accuracy_mse_threshold,
        endpoint_instance_type,
    ],
    steps=[step_preprocess_data, step_train_model, step_evaluate_model, step_cond],
)

किसी भिन्न खाते से मॉडल संस्करण परिनियोजित करें

अब जब मॉडल साझा सेवा खाते में पंजीकृत हो गया है, तो हमें परिनियोजन खाते में CI/CD पाइपलाइन का उपयोग करके अपने वर्कलोड खातों में तैनात करने की आवश्यकता है। हमने पहले ही चरण में भूमिका और नीति को कॉन्फ़िगर कर लिया है। हम मॉडल रजिस्ट्री से मॉडल को परिनियोजित करने के लिए मॉडल पैकेज ARN का उपयोग करते हैं। निम्नलिखित कोड परिनियोजन खाते में चलता है और QA और उत्पादों के लिए स्वीकृत मॉडल को परिनियोजित करने के लिए उपयोग किया जाता है:

from sagemaker import ModelPackage
from time import gmtime, strftime

sagemaker_session = sagemaker.Session(boto_session=sess)

model_package_arn = 'arn:aws:sagemaker:::/modeltest/version_number'
model = ModelPackage(role=role, 
                     model_package_arn=model_package_arn, 
                     sagemaker_session=sagemaker_session)
model.deploy(initial_instance_count=1, instance_type='ml.m5.xlarge')

निष्कर्ष

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

आप इस पोस्ट में अवधारणाओं को होस्ट करने के लिए मॉडल को स्केल कर सकते हैं अमेज़ॅन इलास्टिक कम्प्यूट क्लाउड (अमेज़न EC2) या अमेज़ॅन इलास्टिक कुबेरनेट्स सेवा (अमेज़ॅन ईकेएस), साथ ही साथ एक बैच इंट्रेंस पाइपलाइन का निर्माण करें।

एडब्ल्यूएस में एमएल मॉडल बनाने वाले अलग खाते के बारे में अधिक जानने के लिए देखें एडब्ल्यूएस संगठनों के साथ संगठनात्मक इकाइयों के लिए सर्वोत्तम अभ्यास और उत्पादन में मॉडल को सुरक्षित रूप से अपडेट करें.

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

संदीप वर्मा AWS के साथ एक सीनियर प्रोटोटाइप आर्किटेक्ट हैं। उन्हें ग्राहकों की चुनौतियों में गहराई से गोता लगाने और नवाचार में तेजी लाने के लिए ग्राहकों के लिए प्रोटोटाइप बनाने में आनंद आता है। उनके पास एआई/एमएल की पृष्ठभूमि है, वे न्यू नॉलेज के संस्थापक हैं, और आम तौर पर तकनीक के प्रति जुनूनी हैं। अपने खाली समय में, वह अपने परिवार के साथ घूमना और स्कीइंग करना पसंद करते हैं।

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

सौमित्र विक्रम Amazon SageMaker टीम में एक सॉफ्टवेयर डेवलपर है और चेन्नई, भारत में स्थित है। काम के बाहर, उन्हें हिमालय के माध्यम से दौड़ना, ट्रेकिंग और मोटर बाइक की सवारी करना पसंद है।

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

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

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