अमेज़ॅन सेजमेकर एंडपॉइंट्स और एडब्ल्यूएस लैम्ब्डा के साथ स्केल YOLOv5 अनुमान

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

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

निम्नलिखित छवि सेजमेकर एंडपॉइंट का उपयोग करके YOLOv5 मॉडल को होस्ट करने के लिए उपयोग की जाने वाली AWS सेवाओं की रूपरेखा तैयार करती है और लैम्ब्डा का उपयोग करके एंडपॉइंट को लागू करती है। सेजमेकर नोटबुक एक YOLOv5 PyTorch मॉडल को a . से एक्सेस करता है अमेज़न सरल भंडारण सेवा (अमेज़ॅन S3) बकेट, इसे YOLOv5 TensorFlow में कनवर्ट करता है SavedModel प्रारूप, और इसे वापस S3 बाल्टी में संग्रहीत करता है। समापन बिंदु की मेजबानी करते समय इस मॉडल का उपयोग किया जाता है। जब Amazon S3 पर एक छवि अपलोड की जाती है, तो यह लैम्ब्डा फ़ंक्शन को चलाने के लिए एक ट्रिगर के रूप में कार्य करती है। फ़ंक्शन OpenCV का उपयोग करता है लैम्ब्डा परतें अपलोड की गई छवि को पढ़ने और समापन बिंदु का उपयोग करके अनुमान चलाने के लिए। निष्कर्ष चलाने के बाद, आप इससे प्राप्त परिणामों का आवश्यकतानुसार उपयोग कर सकते हैं।

इस पोस्ट में, हम PyTorch में YOLOv5 डिफ़ॉल्ट मॉडल का उपयोग करने और इसे TensorFlow में बदलने की प्रक्रिया से गुजरते हैं SavedModel. इस मॉडल को सेजमेकर एंडपॉइंट का उपयोग करके होस्ट किया गया है। फिर हम एक लैम्ब्डा फ़ंक्शन बनाते और प्रकाशित करते हैं जो निष्कर्ष को चलाने के लिए समापन बिंदु को आमंत्रित करता है। पूर्व-प्रशिक्षित YOLOv5 मॉडल पर उपलब्ध हैं GitHub. इस पोस्ट के प्रयोजन के लिए, हम उपयोग करते हैं योलोव5एल मॉडल.

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

एक शर्त के रूप में, हमें निम्नलिखित स्थापित करने की आवश्यकता है: AWS पहचान और अभिगम प्रबंधन (IAM) भूमिकाओं के साथ उपयुक्त पहुँच नीतियां सेजमेकर, लैम्ब्डा और अमेज़न S3 के लिए:

• सेजमेकर आईएएम भूमिका - इस आवश्यकता है AmazonS3FullAccess S3 बकेट में मॉडल को स्टोर करने और एक्सेस करने के लिए संलग्न नीतियां
• लैम्ब्डा आईएएम भूमिका - इस भूमिका के लिए कई नीतियों की आवश्यकता है:
  • Amazon S3 में संग्रहीत छवियों तक पहुँचने के लिए, हमें निम्नलिखित IAM नीतियों की आवश्यकता है:
    • s3:GetObject
    • s3:ListBucket
  • सेजमेकर एंडपॉइंट चलाने के लिए, हमें निम्नलिखित आईएएम नीतियों तक पहुंच की आवश्यकता है:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

आपको निम्नलिखित संसाधनों और सेवाओं की भी आवश्यकता है:

• RSI AWS कमांड लाइन इंटरफ़ेस (एडब्ल्यूएस सीएलआई), जिसका उपयोग हम लैम्ब्डा को बनाने और कॉन्फ़िगर करने के लिए करते हैं।
• एक सेजमेकर नोटबुक उदाहरण। ये पहले से स्थापित डॉकर के साथ आते हैं, और हम इसका उपयोग लैम्ब्डा परत बनाने के लिए करते हैं। नोटबुक इंस्टेंस सेट करने के लिए, निम्न चरणों को पूरा करें:
  • SageMaker कंसोल पर, एक नोटबुक इंस्टेंस बनाएं और नोटबुक का नाम, इंस्टेंस प्रकार (इस पोस्ट के लिए, हम ml.c5.large का उपयोग करें), IAM भूमिका और अन्य पैरामीटर प्रदान करें।
  • क्लोन किया गया सार्वजनिक भंडार और जोड़ें YOLOv5 भंडार अल्ट्रालाइटिक्स द्वारा प्रदान किया गया।

YOLOv5 को सेजमेकर एंडपॉइंट पर होस्ट करें

इससे पहले कि हम सेजमेकर पर पूर्व-प्रशिक्षित YOLOv5 मॉडल की मेजबानी कर सकें, हमें इसे सही निर्देशिका संरचना में निर्यात और पैकेज करना होगा। model.tar.gz. इस पोस्ट के लिए, हम प्रदर्शित करते हैं कि YOLOv5 को कैसे होस्ट किया जाए saved_model प्रारूप। YOLOv5 रेपो एक प्रदान करता है export.py फ़ाइल जो मॉडल को कई अलग-अलग तरीकों से निर्यात कर सकती है। YOLOv5 को क्लोन करने और कमांड लाइन से YOLOv5 निर्देशिका दर्ज करने के बाद, आप निम्न कमांड के साथ मॉडल को निर्यात कर सकते हैं:

$ cd yolov5
$ pip install -r requirements.txt tensorflow-cpu
$ python export.py --weights yolov5l.pt --include saved_model --nms

यह आदेश एक नई निर्देशिका बनाता है जिसे कहा जाता है yolov5l_saved_model अंदर yolov5 निर्देशिका। के अंदर yolov5l_saved_model निर्देशिका, हमें निम्नलिखित आइटम देखना चाहिए:

yolov5l_saved_model
    ├─ assets
    ├─ variables
    │    ├── variables.data-00000-of-00001
    │    └── variables.index
    └── saved_model.pb

बनाने के लिए model.tar.gz फ़ाइल, की सामग्री को स्थानांतरित करें yolov5l_saved_model सेवा मेरे export/Servo/1. कमांड लाइन से, हम को कंप्रेस कर सकते हैं export निम्न आदेश चलाकर निर्देशिका और मॉडल को S3 बाल्टी में अपलोड करें:

$ mkdir export && mkdir export/Servo
$ mv yolov5l_saved_model export/Servo/1
$ tar -czvf model.tar.gz export/
$ aws s3 cp model.tar.gz "<s3://BUCKET/PATH/model.tar.gz>"

फिर, हम निम्नलिखित कोड चलाकर सेजमेकर नोटबुक से सेजमेकर एंडपॉइंट को तैनात कर सकते हैं:

import os
import tensorflow as tf
from tensorflow.keras import backend
from sagemaker.tensorflow import TensorFlowModel

model_data = '<s3://BUCKET/PATH/model.tar.gz>'
role = '<IAM ROLE>'

model = TensorFlowModel(model_data=model_data,
                        framework_version='2.8', role=role)

INSTANCE_TYPE = 'ml.m5.xlarge'
ENDPOINT_NAME = 'yolov5l-demo'

predictor = model.deploy(initial_instance_count=1,
                            instance_type=INSTANCE_TYPE,
                            endpoint_name=ENDPOINT_NAME)

पिछली स्क्रिप्ट को सेजमेकर एंडपॉइंट पर मॉडल को पूरी तरह से तैनात करने में लगभग 2-3 मिनट लगते हैं। आप सेजमेकर कंसोल पर परिनियोजन की स्थिति की निगरानी कर सकते हैं। मॉडल को सफलतापूर्वक होस्ट करने के बाद, मॉडल अनुमान के लिए तैयार है।

सेजमेकर एंडपॉइंट का परीक्षण करें

सेजमेकर एंडपॉइंट पर मॉडल को सफलतापूर्वक होस्ट करने के बाद, हम इसका परीक्षण कर सकते हैं, जो हम एक रिक्त छवि का उपयोग करके करते हैं। परीक्षण कोड इस प्रकार है:

import numpy as np

ENDPOINT_NAME = 'yolov5l-demo'

modelHeight, modelWidth = 640, 640
blank_image = np.zeros((modelHeight,modelWidth,3), np.uint8)
data = np.array(resized_image.astype(np.float32)/255.)
payload = json.dumps([data.tolist()])
response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME,
ContentType='application/json',
Body=payload)

result = json.loads(response['Body'].read().decode())
print('Results: ', result)

लैम्ब्डा को लेयर्स और ट्रिगर्स के साथ सेट करें

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

हमारे पास परतें होने के बाद, हम बनाते हैं app.py स्क्रिप्ट, जो लैम्ब्डा कोड है जो परतों का उपयोग करता है, अनुमान चलाता है, और परिणाम प्राप्त करता है। निम्न आरेख इस वर्कफ़्लो को दिखाता है।

डॉकर का उपयोग करके ओपनसीवी के लिए लैम्ब्डा परतें बनाएं

पायथन 3.7 का उपयोग करके डॉकर छवि बनाने के लिए डॉकरफाइल का उपयोग इस प्रकार करें:

FROM amazonlinux

RUN yum update -y
RUN yum install gcc openssl-devel bzip2-devel libffi-devel wget tar gzip zip make -y

# Install Python 3.7
WORKDIR /
RUN wget https://www.python.org/ftp/python/3.7.12/Python-3.7.12.tgz
RUN tar -xzvf Python-3.7.12.tgz
WORKDIR /Python-3.7.12
RUN ./configure --enable-optimizations
RUN make altinstall

# Install Python packages
RUN mkdir /packages
RUN echo "opencv-python" >> /packages/requirements.txt
RUN mkdir -p /packages/opencv-python-3.7/python/lib/python3.7/site-packages
RUN pip3.7 install -r /packages/requirements.txt -t /packages/opencv-python-3.7/python/lib/python3.7/site-packages

# Create zip files for Lambda Layer deployment
WORKDIR /packages/opencv-python-3.7/
RUN zip -r9 /packages/cv2-python37.zip .
WORKDIR /packages/
RUN rm -rf /packages/opencv-python-3.7/

डॉकर बनाएं और चलाएं और आउटपुट ज़िप फ़ाइल को वर्तमान निर्देशिका में संग्रहीत करें layers:

$ docker build --tag aws-lambda-layers:latest <PATH/TO/Dockerfile>
$ docker run -rm -it -v $(pwd):/layers aws-lambda-layers cp /packages/cv2-python37.zip /layers

अब हम OpenCV परत की कलाकृतियों को Amazon S3 पर अपलोड कर सकते हैं और लैम्ब्डा परत बना सकते हैं:

$ aws s3 cp layers/cv2-python37.zip s3://<BUCKET>/<PATH/TO/STORE/ARTIFACTS>
$ aws lambda publish-layer-version --layer-name cv2 --description "Open CV" --content S3Bucket=<BUCKET>,S3Key=<PATH/TO/STORE/ARTIFACTS>/cv2-python37.zip --compatible-runtimes python3.7

पिछले आदेश सफलतापूर्वक चलने के बाद, आपके पास लैम्ब्डा में एक ओपनसीवी परत है, जिसे आप लैम्ब्डा कंसोल पर समीक्षा कर सकते हैं।

लैम्ब्डा फ़ंक्शन बनाएं

हम का उपयोग करते हैं app.py लैम्ब्डा फ़ंक्शन बनाने और OpenCV का उपयोग करने के लिए स्क्रिप्ट। निम्नलिखित कोड में, के लिए मान बदलें BUCKET_NAME और IMAGE_LOCATION छवि तक पहुँचने के लिए स्थान पर:

import os, logging, json, time, urllib.parse
import boto3, botocore
import numpy as np, cv2

logger = logging.getLogger()
logger.setLevel(logging.INFO)
client = boto3.client('lambda')

# S3 BUCKETS DETAILS
s3 = boto3.resource('s3')
BUCKET_NAME = "<NAME OF S3 BUCKET FOR INPUT IMAGE>"
IMAGE_LOCATION = "<S3 PATH TO IMAGE>/image.png"

# INFERENCE ENDPOINT DETAILS
ENDPOINT_NAME = 'yolov5l-demo'
config = botocore.config.Config(read_timeout=80)
runtime = boto3.client('runtime.sagemaker', config=config)
modelHeight, modelWidth = 640, 640

# RUNNING LAMBDA
def lambda_handler(event, context):
    key = urllib.parse.unquote_plus(event['Records'][0]['s3']['object']['key'], encoding='utf-8')

    # INPUTS - Download Image file from S3 to Lambda /tmp/
    input_imagename = key.split('/')[-1]
    logger.info(f'Input Imagename: {input_imagename}')
    s3.Bucket(BUCKET_NAME).download_file(IMAGE_LOCATION + '/' + input_imagename, '/tmp/' + input_imagename)

    # INFERENCE - Invoke the SageMaker Inference Endpoint
    logger.info(f'Starting Inference ... ')
    orig_image = cv2.imread('/tmp/' + input_imagename)
    if orig_image is not None:
        start_time_iter = time.time()
        # pre-processing input image
        image = cv2.resize(orig_image.copy(), (modelWidth, modelHeight), interpolation = cv2.INTER_AREA)
        data = np.array(image.astype(np.float32)/255.)
        payload = json.dumps([data.tolist()])
        # run inference
        response = runtime.invoke_endpoint(EndpointName=ENDPOINT_NAME, ContentType='application/json', Body=payload)
        # get the output results
        result = json.loads(response['Body'].read().decode())
        end_time_iter = time.time()
        # get the total time taken for inference
        inference_time = round((end_time_iter - start_time_iter)*100)/100
    logger.info(f'Inference Completed ... ')

    # OUTPUTS - Using the output to utilize in other services downstream
    return {
        "statusCode": 200,
        "body": json.dumps({
                "message": "Inference Time:// " + str(inference_time) + " seconds.",
                "results": result
                }),
            }

निम्नलिखित कोड के साथ लैम्ब्डा फ़ंक्शन को परिनियोजित करें:

$ zip app.zip app.py
$ aws s3 cp app.zip s3://<BUCKET>/<PATH/TO/STORE/FUNCTION>
$ aws lambda create-function --function-name yolov5-lambda --handler app.lambda_handler --region us-east-1 --runtime python3.7 --environment "Variables={BUCKET_NAME=$BUCKET_NAME,S3_KEY=$S3_KEY}" --code S3Bucket=<BUCKET>,S3Key="<PATH/TO/STORE/FUNCTION/app.zip>"

लैम्ब्डा फ़ंक्शन के लिए OpenCV परत संलग्न करें

हमारे पास लैम्ब्डा फ़ंक्शन और परत होने के बाद, हम परत को फ़ंक्शन से निम्नानुसार जोड़ सकते हैं:

$ aws lambda update-function-configuration --function-name yolov5-lambda --layers cv2

हम लैम्ब्डा कंसोल के माध्यम से परत सेटिंग्स की समीक्षा कर सकते हैं।

जब Amazon S3 पर कोई छवि अपलोड की जाती है तो लैम्ब्डा को ट्रिगर करें

हम लैम्ब्डा फ़ंक्शन को चलाने के लिए ट्रिगर के रूप में Amazon S3 पर एक छवि अपलोड का उपयोग करते हैं। निर्देशों के लिए, देखें ट्यूटोरियल: लैम्ब्डा फ़ंक्शन को लागू करने के लिए Amazon S3 ट्रिगर का उपयोग करना.

आपको लैम्ब्डा कंसोल पर निम्नलिखित फ़ंक्शन विवरण देखना चाहिए।

अनुमान चलाएँ

लैम्ब्डा और सेजमेकर एंडपॉइंट सेट करने के बाद, आप लैम्ब्डा फ़ंक्शन को लागू करके आउटपुट का परीक्षण कर सकते हैं। हम लैम्ब्डा को आमंत्रित करने के लिए ट्रिगर के रूप में अमेज़ॅन एस 3 पर एक छवि अपलोड का उपयोग करते हैं, जो बदले में निष्कर्ष के लिए समापन बिंदु को आमंत्रित करता है। एक उदाहरण के रूप में, हम निम्नलिखित छवि को Amazon S3 स्थान पर अपलोड करते हैं <S3 PATH TO IMAGE>/test_image.png पिछले अनुभाग में कॉन्फ़िगर किया गया।

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

क्लीन अप

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

निष्कर्ष

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

सेजमेकर एंडपॉइंट्स के बारे में अधिक जानने के लिए, देखें अपना समापन बिंदु बनाएं और अपना मॉडल परिनियोजित करें और AWS लैम्ब्डा में अपने Amazon SageMaker अनुमान मॉडल का निर्माण, परीक्षण और परिनियोजन करें, जो इस बात पर प्रकाश डालता है कि आप YOLOv5 मॉडल को परिनियोजित करने की प्रक्रिया को कैसे स्वचालित कर सकते हैं।

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

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

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