PyTorch Model Zoo का उपयोग करके Amazon SageMaker मॉडल बनाएं

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

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

हम फास्टर आर-सीएनएन ऑब्जेक्ट डिटेक्शन मॉडल वेट को लोड करने से लेकर उन्हें सेव करने तक, एंड-टू-एंड उदाहरण के माध्यम से चलते हैं अमेज़न सरल भंडारण सेवा (अमेज़न S3) बाल्टी, और एक एंट्रीपॉइंट फ़ाइल लिखने और PyTorchModel API में प्रमुख मापदंडों को समझने के लिए। अंत में, हम ML मॉडल को तैनात करेंगे, SageMaker बैच ट्रांसफ़ॉर्म का उपयोग करके उस पर अनुमान लगाएंगे, और ML मॉडल आउटपुट का निरीक्षण करेंगे और सीखेंगे कि परिणामों की व्याख्या कैसे करें। यह समाधान PyTorch Model Zoo पर किसी अन्य पूर्व-प्रशिक्षित मॉडल पर लागू किया जा सकता है। उपलब्ध मॉडलों की सूची के लिए, देखें PyTorch मॉडल चिड़ियाघर प्रलेखन.

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

यह ब्लॉग पोस्ट निम्नलिखित चरणों से गुजरेगी। सभी चरणों के पूर्ण कार्यशील संस्करण के लिए, देखें create_pytorch_model_sagemaker.ipynb

• चरण 1: सेटअप
• चरण 2: PyTorch Model Zoo से एमएल मॉडल लोड करना
• चरण 3 ML मॉडल कलाकृतियों को Amazon S3 में सहेजें और अपलोड करें
• चरण 4: एमएल मॉडल अनुमान स्क्रिप्ट का निर्माण
• चरण 5: एक SageMaker बैच ट्रांसफ़ॉर्म जॉब लॉन्च करना
• चरण 6: परिणामों की कल्पना करना

वास्तुकला आरेख

निर्देशिका संरचना

इस ब्लॉग का कोड इसमें पाया जा सकता है गिटहब भंडार. कोडबेस में वह सब कुछ है जो हमें एमएल मॉडल कलाकृतियों के निर्माण, परिवर्तन कार्य को लॉन्च करने और परिणामों की कल्पना करने के लिए चाहिए।

यह वह वर्कफ़्लो है जिसका हम उपयोग करते हैं। निम्नलिखित सभी चरण इस संरचना में मॉड्यूल को संदर्भित करेंगे।

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

RSI sagemaker_torch_model_zoo फ़ोल्डर में होना चाहिए inference.py एक एंट्रीपॉइंट फ़ाइल के रूप में, और create_pytorch_model_sagemaker.ipynb मॉडल वेट को लोड और सेव करने के लिए, एक SageMaker मॉडल ऑब्जेक्ट बनाएँ, और अंत में उसे एक SageMaker बैच ट्रांसफ़ॉर्म जॉब में पास करें। अपने स्वयं के एमएल मॉडल लाने के लिए, चरण 1 में पथ बदलें: नोटबुक का सेटअप अनुभाग और चरण 2 में एक नया मॉडल लोड करें: PyTorch मॉडल चिड़ियाघर अनुभाग से एक एमएल मॉडल लोड करना। नीचे दिए गए शेष चरण समान रहेंगे।

चरण 1: सेटअप

IAM भूमिकाएं

SageMaker SageMaker द्वारा प्रबंधित बुनियादी ढांचे पर संचालन करता है। SageMaker केवल SageMaker के लिए नोटबुक के साथ IAM निष्पादन भूमिका में परिभाषित के रूप में अनुमत कार्य कर सकता है। IAM भूमिकाएँ बनाने और IAM अनुमतियाँ प्रबंधित करने के बारे में अधिक विस्तृत दस्तावेज़ीकरण के लिए, देखें AWS SageMaker भूमिकाओं का दस्तावेज़ीकरण. हम एक नई भूमिका बना सकते हैं, या हम प्राप्त कर सकते हैं सेजमेकर (स्टूडियो) नोटबुककोड की निम्नलिखित पंक्तियों को चलाकर डिफ़ॉल्ट निष्पादन भूमिका:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

उपरोक्त कोड को नोटबुक उदाहरण के लिए SageMaker निष्पादन भूमिका मिलती है। यह IAM भूमिका है जिसे हमने अपने SageMaker या SageMaker Studio नोटबुक उदाहरण के लिए बनाया है।

उपयोगकर्ता विन्यास योग्य पैरामीटर

हमारे SageMaker बैच ट्रांसफ़ॉर्म जॉब को बनाने और लॉन्च करने के लिए आवश्यक सभी कॉन्फ़िगर करने योग्य पैरामीटर यहां दिए गए हैं:

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

चरण 2: PyTorch Model Zoo से एमएल मॉडल लोड करना

इसके बाद, हम PyTorch Model Zoo से एक ऑब्जेक्ट डिटेक्शन मॉडल निर्दिष्ट करते हैं और इसके ML मॉडल वेट को सेव करते हैं। आमतौर पर, हम .pt या .pth फ़ाइल एक्सटेंशन का उपयोग करके PyTorch मॉडल को सहेजते हैं। नीचे दिया गया कोड स्निपेट PyTorch Model Zoo से एक पूर्व-प्रशिक्षित तेज़ R-CNN ResNet50 ML मॉडल डाउनलोड करता है:

मॉडल = टॉर्चविजन.मॉडल.डिटेक्शन.फास्टरआरसीएनएन_रेसनेट50_एफपीएन (पूर्वप्रशिक्षित = सच)

SageMaker बैच ट्रांसफ़ॉर्म के लिए इनपुट के रूप में कुछ मॉडल वेट की आवश्यकता होती है, इसलिए हम पूर्व-प्रशिक्षित ML मॉडल को model.pt के रूप में सहेजेंगे। यदि हम एक कस्टम मॉडल को लोड करना चाहते हैं, तो हम इसके बजाय मॉडल के वजन को किसी अन्य PyTorch मॉडल से model.pt के रूप में सहेज सकते हैं।

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

चरण 3: एमएल मॉडल कलाकृतियों को अमेज़ॅन एस 3 में सहेजें और अपलोड करें

चूँकि हम ML अनुमान के लिए SageMaker का उपयोग कर रहे हैं, इसलिए हमें S3 बकेट में मॉडल भार अपलोड करने की आवश्यकता है। हम निम्न आदेशों का उपयोग करके या डाउनलोड करके और फ़ाइल को सीधे S3 में खींचकर और छोड़ कर ऐसा कर सकते हैं। निम्न आदेश पहले फ़ाइलों के समूह को संपीड़ित करेंगे model.pt एक टारबॉल के लिए और हमारे स्थानीय मशीन से S3 बकेट में मॉडल वेट कॉपी करें।

नोट: निम्नलिखित कमांड चलाने के लिए, आपके पास होना चाहिए AWS कमांड लाइन इंटरफ़ेस (AWS CLI) स्थापित.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

अगला, हम अपनी इनपुट छवि को S3 पर कॉपी करते हैं। छवि के लिए नीचे पूर्ण S3 पथ है।

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

हम इस इमेज को दूसरे aws s3 cp कमांड से S3 में कॉपी कर सकते हैं।

aws s3 cp cars.jpg $car_image_path

चरण 4: एमएल मॉडल अनुमान स्क्रिप्ट का निर्माण

अब हम अपनी एंट्रीपॉइंट फाइल पर जाएंगे, inference.py मापांक। हम PyTorchModel वर्ग का उपयोग करके SageMaker के बाहर प्रशिक्षित PyTorch मॉडल को परिनियोजित कर सकते हैं। सबसे पहले, हम PyTorchModelZoo ऑब्जेक्ट को इंस्टेंट करते हैं। फिर हम Amazon S3 में होस्ट किए गए नमूना डेटा पर SageMaker बैच ट्रांसफ़ॉर्म का उपयोग करके ML अनुमान लगाने के लिए एक inference.py entrypoint फ़ाइल का निर्माण करेंगे।

PyTorchModel वस्तु को समझना

RSI PyTorchमॉडल SageMaker Python API के भीतर क्लास हमें हमारे डाउनलोड किए गए मॉडल आर्टिफैक्ट का उपयोग करके एमएल अनुमान लगाने की अनुमति देता है।

PyTorchModel क्लास शुरू करने के लिए, हमें निम्नलिखित इनपुट पैरामीटर्स को समझने की आवश्यकता है:

• name: मॉडल नाम; हम विशिष्टता के लिए या तो मॉडल का नाम + दिनांक समय, या एक यादृच्छिक स्ट्रिंग + दिनांक समय का उपयोग करने की अनुशंसा करते हैं।
• model_data: पैकेज्ड ML मॉडल विरूपण साक्ष्य का S3 URI।
• entry_point: आने वाले अनुरोधों के लिए हैंडलर को परिभाषित करने के लिए अनुमान डॉकर छवि द्वारा उपयोग की जाने वाली उपयोगकर्ता-परिभाषित पायथन फ़ाइल। कोड मॉडल लोडिंग, इनपुट प्रीप्रोसेसिंग, प्रेडिक्शन लॉजिक और आउटपुट पोस्ट-प्रोसेसिंग को परिभाषित करता है।
• framework_version: स्वचालित PyTorch मॉडल रीपैकेजिंग को सक्षम करने के लिए संस्करण 1.2 या उच्चतर पर सेट करने की आवश्यकता है।
• source_dir: entry_point फ़ाइल की निर्देशिका।
• role: एडब्ल्यूएस सेवा अनुरोध करने के लिए एक आईएएम भूमिका।
• image_uri: एमएल मॉडल कंप्यूट पर्यावरण के लिए आधार के रूप में इस अमेज़ॅन ईसीआर डॉकर कंटेनर छवि का उपयोग करें।
• sagemaker_session: सेजमेकर सत्र।
• py_version: उपयोग करने के लिए पायथन संस्करण

निम्न कोड स्निपेट PyTorchModel वर्ग को पूर्व-प्रशिक्षित PyTorch मॉडल का उपयोग करके अनुमान लगाने के लिए त्वरित करता है:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

एंट्रीपॉइंट फ़ाइल को समझना (inference.py)

entry_point पैरामीटर नाम की एक Python फ़ाइल की ओर इशारा करता है inference.py. यह एंट्रीपॉइंट मॉडल लोडिंग, इनपुट प्रीप्रोसेसिंग, प्रेडिक्शन लॉजिक और आउटपुट पोस्ट-प्रोसेसिंग को परिभाषित करता है। यह पूर्वनिर्मित PyTorch में ML मॉडल सर्विंग कोड को पूरक करता है सेजमेकर डीप लर्निंग कंटेनर छवि।

Inference.py निम्नलिखित कार्य होंगे। हमारे उदाहरण में, हम इसे लागू करते हैं model_fn, input_fn, predict_fn और output_fn ओवरराइड करने के लिए कार्य करता है डिफ़ॉल्ट PyTorch अनुमान हैंडलर.

1. model_fn: अनुमान छवि में स्थिर मॉडल चौकियों वाली निर्देशिका में ले जाता है। मॉडल को एक निर्दिष्ट पथ से खोलता है और लोड करता है और एक PyTorch मॉडल लौटाता है।
2. input_fn: आने वाले अनुरोध (request_body) के पेलोड और इनपुट के रूप में आने वाले अनुरोध (request_content_type) के सामग्री प्रकार को लेता है। डेटा डिकोडिंग को संभालता है। मॉडल किस इनपुट की अपेक्षा कर रहा है, इसके लिए इस फ़ंक्शन को समायोजित करने की आवश्यकता है।
3. predict_fn: इनपुट_एफएन में डेटा को डेटा पर एक मॉडल को कॉल करता है। लोड किए गए एमएल मॉडल के साथ डिसेरिएलाइज्ड ऑब्जेक्ट पर भविष्यवाणी करता है।
4. output_fn: वांछित प्रतिक्रिया सामग्री प्रकार में भविष्यवाणी परिणाम को क्रमबद्ध करता है। Predict_fn फ़ंक्शन से प्राप्त भविष्यवाणियों को JSON, CSV या NPY स्वरूपों में कनवर्ट करता है।

चरण 5: एक SageMaker बैच ट्रांसफ़ॉर्म जॉब लॉन्च करना

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

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

बैच ट्रांस्फ़ॉर्म जॉब बनाने के लिए दस्तावेज़ देखें क्रिएटट्रांसफॉर्मजॉब.

चरण 6: परीक्षण की कल्पना करना

एक बार जब SageMaker बैच ट्रांसफ़ॉर्म का काम पूरा कर लेता है, तो हम Amazon S3 से ML इंट्रेंस आउटपुट लोड कर सकते हैं। इसके लिए, पर नेविगेट करें एडब्ल्यूएस प्रबंधन कंसोल और Amazon SageMaker को खोजें। बाएं पैनल पर, नीचे अनुमानदेखते हैं, बैच परिवर्तन नौकरियां.

चयन करने के बाद बैच परिवर्तन, सभी SageMaker बैच ट्रांसफ़ॉर्म जॉब्स को सूचीबद्ध करने वाला वेबपेज देखें। हम अपने सबसे हाल के कार्य निष्पादन की प्रगति देख सकते हैं।

सबसे पहले, कार्य की स्थिति "प्रगति में" होगी। एक बार यह हो जाने के बाद, स्थिति को पूर्ण में परिवर्तन देखें।

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

के अंतर्गत आउटपुट डेटा कॉन्फ़िगरेशन, हम एक S3 आउटपुट पाथ देखेंगे। यह वह जगह है जहां हम अपने एमएल इंट्रेंस आउटपुट पाएंगे।

S3 आउटपुट पथ का चयन करें और हमारे आउटपुट डेटा के साथ [image_name].[file_type].out फ़ाइल देखें। हमारी आउटपुट फाइल में मैपिंग की एक सूची होगी। उदाहरण आउटपुट:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

इन भविष्यवाणियों की कल्पना करने के लिए, हम पहले अपने ट्रांसफॉर्मर ऑब्जेक्ट से आउटपुट पथ को पढ़ते हैं।

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

इसके बाद, हम इस आउटपुट फाइल को प्रोसेस करते हैं और अपनी भविष्यवाणियों की कल्पना करते हैं। नीचे हम अपनी विश्वास सीमा निर्दिष्ट करते हैं। हम वर्गों की सूची से प्राप्त करते हैं COCO डेटासेट ऑब्जेक्ट मैपिंग। अनुमान के दौरान, मॉडल को केवल इनपुट टेन्सर की आवश्यकता होती है और पोस्ट-प्रोसेस्ड भविष्यवाणियों को सूची [डिक्ट [टेंसर]] के रूप में लौटाता है, प्रत्येक इनपुट छवि के लिए एक। डिक्ट के क्षेत्र इस प्रकार हैं, जहां N पता लगाने की संख्या है:

1. बक्से (फ्लोटटेन्सर [एन, 4]): अनुमानित बक्से में [x1, y1, x2, y2] प्रारूप, के साथ 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, जहां W छवि की चौड़ाई है और H छवि की ऊंचाई है
2. लेबल (Int64Tensor[N]): प्रत्येक पहचान के लिए अनुमानित लेबल
3. स्कोर (Tensor[N]): प्रत्येक पहचान के लिए भविष्यवाणी स्कोर

आउटपुट पर अधिक विवरण के लिए, देखें PyTorch तेज़ R-CNN FPN दस्तावेज़ीकरण.

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

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

अंत में, हम अपने आउटपुट को समझने के लिए इन मैपिंग की कल्पना करते हैं।

नोट: यदि छवि आपकी नोटबुक में प्रदर्शित नहीं होती है, तो कृपया इसे JupyterLab के बाईं ओर डायरेक्टरी ट्री में खोजें और इसे वहां से खोलें।

उदाहरण कोड चलाना

पूर्ण कामकाजी उदाहरण के लिए, कोड को क्लोन करें अमेज़ॅन-सेजमेकर-उदाहरण गिटहब और कोशिकाओं को चलाते हैं create_pytorch_model_sagemaker.ipynb स्मरण पुस्तक।

निष्कर्ष

इस ब्लॉग पोस्ट में, हमने SageMaker बैच ट्रांसफ़ॉर्म का उपयोग करके PyTorch मॉडल ज़ू से ऑब्जेक्ट डिटेक्शन मॉडल का उपयोग करके ML अनुमान लगाने का एंड-टू-एंड उदाहरण दिखाया। हमने फास्टर आर-सीएनएन ऑब्जेक्ट डिटेक्शन मॉडल वेट लोड करना, उन्हें S3 बकेट में सहेजना, एक एंट्रीपॉइंट फ़ाइल लिखना और PyTorchModel API में प्रमुख मापदंडों को समझना शामिल किया। अंत में, हमने मॉडल को तैनात किया और एमएल मॉडल का अनुमान लगाया, मॉडल आउटपुट की कल्पना की और परिणामों की व्याख्या करना सीखा।

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

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

मार्सेलो एबरले AWS AI संगठन में एक एमएल इंजीनियर है। वह MLOps के प्रयासों का नेतृत्व कर रहा है अमेज़न एमएल सॉल्यूशंस लैब, ग्राहकों को स्केलेबल एमएल सिस्टम डिजाइन और कार्यान्वित करने में मदद करना। उनका मिशन ग्राहकों को उनकी उद्यम एमएल यात्रा पर मार्गदर्शन करना और उत्पादन के लिए उनके एमएल पथ को तेज करना है।

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

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