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

यह पोस्ट आपको बताती है कि लैंबडा के साथ किसी भी TensorFlow मॉडल का उपयोग 10 जीबी मेमोरी के साथ उत्पादन में स्केलेबल इनफॉरमेशन के लिए कैसे किया जाता है। यह हमें कुछ गिगाबाइट्स तक लम्बे कार्यों में एमएल मॉडल का उपयोग करने की अनुमति देता है। इस पोस्ट के लिए, हम TensorFlow-Keras का पूर्व-प्रशिक्षित उपयोग करते हैं रेसनेट50 छवि वर्गीकरण के लिए।

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

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

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

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

इस पूर्वाभ्यास के लिए, आपके पास निम्नलिखित शर्तें होनी चाहिए:

समाधान को लागू करना

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

समाधान को लागू करने के लिए, निम्नलिखित चरणों को पूरा करें:

1. अपनी स्थानीय मशीन पर, नाम के साथ एक फ़ोल्डर बनाएँ lambda-tensorflow-example.
2. बनाओ requirements.txt उस निर्देशिका में फ़ाइल करें।
3. अपने एमएल मॉडल के लिए सभी आवश्यक पुस्तकालयों को जोड़ें। इस पोस्ट के लिए, हम TensorFlow 2.4 का उपयोग करते हैं।
4. एक बनाएं app.py स्क्रिप्ट जिसमें लैम्ब्डा फ़ंक्शन के लिए कोड होता है।
5. एक ही डायरेक्टरी में एक डॉकरीफाइल बनाएं।

निम्न पाठ हमारे उपयोग के मामले के लिए TensorFlow कोड चलाने के लिए आवश्यकताएँ.txt फ़ाइल का एक उदाहरण है:

# List all python libraries for the lambda
tensorflow==2.4.0
tensorflow_hub==0.11
Pillow==8.0.1

हम TensorFlow 2.4 संस्करण का उपयोग केवल CPU समर्थन के साथ कर रहे हैं, क्योंकि इस लेखन के रूप में, Lambda केवल CPU समर्थन प्रदान करता है। TensorFlow के CPU-केवल संस्करणों के बारे में अधिक जानकारी के लिए, देखें पैकेज का स्थान.

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

import json
import boto3
import numpy as np
import PIL.Image as Image import tensorflow as tf
import tensorflow_hub as hub IMAGE_WIDTH = 224
IMAGE_HEIGHT = 224 IMAGE_SHAPE = (IMAGE_WIDTH, IMAGE_HEIGHT)
model = tf.keras.Sequential([hub.KerasLayer("model/")])
model.build([None, IMAGE_WIDTH, IMAGE_HEIGHT, 3]) imagenet_labels= np.array(open('model/ImageNetLabels.txt').read().splitlines())
s3 = boto3.resource('s3') def lambda_handler(event, context): bucket_name = event['Records'][0]['s3']['bucket']['name'] key = event['Records'][0]['s3']['object']['key'] img = readImageFromBucket(key, bucket_name).resize(IMAGE_SHAPE) img = np.array(img)/255.0 prediction = model.predict(img[np.newaxis, ...]) predicted_class = imagenet_labels[np.argmax(prediction[0], axis=-1)] print('ImageName: {0}, Prediction: {1}'.format(key, predicted_class)) def readImageFromBucket(key, bucket_name): bucket = s3.Bucket(bucket_name) object = bucket.Object(key) response = object.get() return Image.open(response['Body'])

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

# Pull the base image with python 3.8 as a runtime for your Lambda
FROM public.ecr.aws/lambda/python:3.8 # Install tar and gzip
RUN yum -y install tar gzip zlib # Copy the earlier created requirements.txt file to the container
COPY requirements.txt ./ # Install the python requirements from requirements.txt
RUN python3.8 -m pip install -r requirements.txt # Copy the earlier created app.py file to the container
COPY app.py ./ # Download ResNet50 and store it in a directory
RUN mkdir model
RUN curl -L https://tfhub.dev/google/imagenet/resnet_v1_50/classification/4?tf-hub-format=compressed -o ./model/resnet.tar.gz
RUN tar -xf model/resnet.tar.gz -C model/
RUN rm -r model/resnet.tar.gz # Download ImageNet labels
RUN curl https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt -o ./model/ImageNetLabels.txt # Set the CMD to your handler
CMD ["app.lambda_handler"]

आपकी फ़ोल्डर संरचना निम्न स्क्रीनशॉट की तरह दिखनी चाहिए।

आप निम्न बैश कमांड के साथ कंटेनर छवि को Amazon ECR पर बना और धकेल सकते हैं। प्रतिस्थापित करें अपनी AWS खाता आईडी के साथ और यह भी निर्दिष्ट करें .

# Build the docker image
docker build -t lambda-tensorflow-example . # Create a ECR repository
aws ecr create-repository --repository-name lambda-tensorflow-example --image-scanning-configuration scanOnPush=true --region <REGION> # Tag the image to match the repository name
docker tag lambda-tensorflow-example:latest <AWS_ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/lambda-tensorflow-example:latest # Register docker to ECR
aws ecr get-login-password --region <REGION> | docker login --username AWS --password-stdin <AWS_ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com # Push the image to ECR
docker push <AWS_ACCOUNT_ID>.dkr.ecr.<REGION>.amazonaws.com/lambda-tensorflow-example:latest

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

एक S3 बाल्टी बनाना

अगले चरण के रूप में, हम छवि वर्ग की भविष्यवाणी करने के लिए उपयोग की जाने वाली छवियों को संग्रहीत करने के लिए एक S3 बाल्टी बनाते हैं।

1. अमेज़न S3 कंसोल पर, चुनें बाल्टी बनाएँ.
2. S3 बाल्टी को एक नाम दें, जैसे कि tensorflow-images-for-inference-<Random_String> और बदलें एक यादृच्छिक मूल्य के साथ।
3. चुनें बाल्टी बनाएँ.

TensorFlow कोड के साथ लैम्ब्डा फ़ंक्शन बनाना

अपना लैम्ब्डा फ़ंक्शन बनाने के लिए, निम्नलिखित चरणों को पूरा करें:

1. लैम्ब्डा कंसोल पर, चुनें कार्य.
2. चुनें फ़ंक्शन बनाएं.
3. चुनते हैं कंटेनर छवि.
4. के लिए कार्य का नाम, जैसे नाम दर्ज करें tensorflow-endpoint.
5. के लिए कंटेनर छवि URI, पहले बनाए गए दर्ज करें lambda-tensorflow-example भंडार।

6. चुनें छवियों को ब्राउज़ करें नवीनतम छवि चुनने के लिए।
7. क्लिक करें फ़ंक्शन बनाएं इसके निर्माण को शुरू करने के लिए।
8. लैम्ब्डा रनटाइम को बेहतर बनाने के लिए, फ़ंक्शन मेमोरी को कम से कम 6 जीबी तक बढ़ाएं और 5 मिनट के लिए समय समाप्त करें मूल सेटिंग्स.

फ़ंक्शन मेमोरी और टाइमआउट सेटिंग्स के बारे में अधिक जानकारी के लिए, देखें AWS लाम्बा के लिए नया - 10 जीबी तक मेमोरी और 6 वीसीपीयू के साथ कार्य.

S3 बाल्टी को अपने लैम्ब्डा फ़ंक्शन से कनेक्ट करना

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

1. लैम्ब्डा कंसोल पर, अपना फ़ंक्शन चुनें।
2. चुनें ट्रिगर जोड़ें.

3. चुनें S3.
4. के लिए बाल्टी, आपके द्वारा पहले बनाई गई बाल्टी का चयन करें।

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

1. पर अनुमतियाँ अपने फ़ंक्शन के लिए टैब, IAM भूमिका चुनें।
2. चुनें नीतियों को संलग्न करें.
3. के लिए खोजें AmazonS3ReadOnlyAccess और इसे IAM भूमिका में संलग्न करें।

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

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

CloudWatch लॉग में पूर्वानुमानित वर्ग मुद्रित होता है। दरअसल, मॉडल चित्र के लिए सही वर्ग की भविष्यवाणी करता है (macaw):

प्रदर्शन

इष्टतम प्रदर्शन प्राप्त करने के लिए, आप मेमोरी सेटिंग के विभिन्न स्तरों की कोशिश कर सकते हैं (जो कि अधिक जानने के लिए, असाइन किए गए vCPU को रैखिक रूप से बदलता है, इसे पढ़ें AWS न्यूज़ ब्लॉग) का है। हमारे तैनात मॉडल के मामले में, हमें लगभग 3GB - 4GB (~ 2vCPUs) सेटिंग में सबसे अधिक प्रदर्शन लाभ का एहसास होता है और इससे आगे का लाभ अपेक्षाकृत कम होता है। विभिन्न मॉडलों में सीपीयू की बढ़ी हुई मात्रा के प्रदर्शन में सुधार के विभिन्न स्तर दिखाई देते हैं, इसलिए यह अपने मॉडल के लिए प्रयोगात्मक रूप से निर्धारित करना सबसे अच्छा है। इसके अतिरिक्त, यह अत्यधिक अनुशंसा की जाती है कि आप अपने स्रोत कोड का लाभ उठाने के लिए संकलित करें उन्नत वेक्टर एक्सटेंशन 2 (AVX2) लैम्ब्डा पर जो कि प्रदर्शन को बढ़ाता है ताकि vCPUs को प्रति घड़ी चक्र में अधिक संख्या में पूर्णांक और फ्लोटिंग-पॉइंट ऑपरेशन चलाने की अनुमति मिले।

निष्कर्ष

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

यदि आपको अपने अनुमान के लिए जीपीयू की आवश्यकता है, तो आप कंटेनर सेवाओं का उपयोग करने पर विचार कर सकते हैं जैसे अमेज़ॅन इलास्टिक कंटेनर सेवा (अमेज़ॅन ईसीएस), कुबेरनेट्स, या मॉडल को ए पर तैनात करें अमेज़न SageMaker समापन बिंदु.

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

जान बाउर AWS व्यावसायिक सेवाओं में क्लाउड एप्लिकेशन डेवलपर है। उनकी रुचियों में सर्वर रहित कंप्यूटिंग, मशीन लर्निंग और सब कुछ शामिल है जिसमें क्लाउड कंप्यूटिंग शामिल है।

स्रोत: https://aws.amazon.com/blogs/machine-learning/using-container-images-to-run-tensorflow-models-in-aws-lambda/