Κλιμακώστε το συμπέρασμα YOLOv5 με τα τελικά σημεία του Amazon SageMaker και το AWS Lambda

Αφού οι επιστήμονες δεδομένων καταλήξουν προσεκτικά σε ένα ικανοποιητικό μοντέλο μηχανικής μάθησης (ML), το μοντέλο πρέπει να αναπτυχθεί ώστε να είναι εύκολα προσβάσιμο για συμπέρασμα από άλλα μέλη του οργανισμού. Ωστόσο, η ανάπτυξη μοντέλων σε κλίμακα με βελτιστοποιημένη απόδοση κόστους και υπολογισμού μπορεί να είναι μια αποθαρρυντική και δυσκίνητη εργασία. Amazon Sage Maker Τα τελικά σημεία παρέχουν μια εύκολα επεκτάσιμη και βελτιστοποιημένη από άποψη κόστους λύση για την ανάπτυξη του μοντέλου. Το μοντέλο YOLOv5, που διανέμεται με την άδεια GPLv3, είναι ένα δημοφιλές μοντέλο ανίχνευσης αντικειμένων γνωστό για την αποτελεσματικότητά του στο χρόνο εκτέλεσης καθώς και για την ακρίβεια ανίχνευσης. Σε αυτήν την ανάρτηση, δείχνουμε πώς να φιλοξενήσετε ένα προεκπαιδευμένο μοντέλο YOLOv5 στα τελικά σημεία του SageMaker και να χρησιμοποιήσετε AWS Lambda συναρτήσεις για την επίκληση αυτών των τελικών σημείων.

Επισκόπηση λύσεων

Η παρακάτω εικόνα περιγράφει τις υπηρεσίες AWS που χρησιμοποιούνται για τη φιλοξενία του μοντέλου YOLOv5 χρησιμοποιώντας ένα τελικό σημείο του SageMaker και την κλήση του τελικού σημείου χρησιμοποιώντας το Lambda. Το σημειωματάριο SageMaker έχει πρόσβαση σε ένα μοντέλο YOLOv5 PyTorch από ένα Απλή υπηρεσία αποθήκευσης Amazon (Amazon S3) κάδος, τον μετατρέπει σε YOLOv5 TensorFlow SavedModel μορφή και το αποθηκεύει πίσω στον κάδο S3. Αυτό το μοντέλο χρησιμοποιείται στη συνέχεια όταν φιλοξενείται το τελικό σημείο. Όταν μια εικόνα μεταφορτώνεται στο Amazon S3, λειτουργεί ως έναυσμα για την εκτέλεση της συνάρτησης Lambda. Η λειτουργία χρησιμοποιεί OpenCV Στρώματα λάμδα για να διαβάσετε τη μεταφορτωμένη εικόνα και να εκτελέσετε συμπέρασμα χρησιμοποιώντας το τελικό σημείο. Αφού εκτελεστεί το συμπέρασμα, μπορείτε να χρησιμοποιήσετε τα αποτελέσματα που προκύπτουν από αυτό όπως απαιτείται.

Σε αυτήν την ανάρτηση, ακολουθούμε τη διαδικασία χρήσης ενός προεπιλεγμένου μοντέλου YOLOv5 στο PyTorch και τη μετατροπή του σε TensorFlow SavedModel. Αυτό το μοντέλο φιλοξενείται χρησιμοποιώντας ένα τελικό σημείο SageMaker. Στη συνέχεια, δημιουργούμε και δημοσιεύουμε μια συνάρτηση Lambda που καλεί το τελικό σημείο για να εκτελέσει το συμπέρασμα. Διατίθενται προεκπαιδευμένα μοντέλα YOLOv5 GitHub. Για τους σκοπούς αυτής της ανάρτησης, χρησιμοποιούμε το yolov5l μοντέλο.

Προϋποθέσεις

Ως προαπαιτούμενο, πρέπει να ρυθμίσουμε τα εξής Διαχείριση ταυτότητας και πρόσβασης AWS (ΙΑΜ) ρόλους με κατάλληλες πολιτικές πρόσβασης για το SageMaker, το Lambda και το Amazon S3:

• Ρόλος SageMaker IAM – Αυτό απαιτεί AmazonS3FullAccess πολιτικές που επισυνάπτονται για την αποθήκευση και την πρόσβαση στο μοντέλο στον κάδο S3
• Λάμδα ΙΑΜ ρόλος – Αυτός ο ρόλος χρειάζεται πολλαπλές πολιτικές:
  • Για πρόσβαση σε εικόνες που είναι αποθηκευμένες στο Amazon S3, απαιτούμε τις ακόλουθες πολιτικές IAM:
    • s3:GetObject
    • s3:ListBucket
  • Για να εκτελέσουμε το τελικό σημείο του SageMaker, χρειαζόμαστε πρόσβαση στις ακόλουθες πολιτικές IAM:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

Χρειάζεστε επίσης τους ακόλουθους πόρους και υπηρεσίες:

• Η Διεπαφή γραμμής εντολών AWS (AWS CLI), το οποίο χρησιμοποιούμε για τη δημιουργία και τη διαμόρφωση του Lambda.
• Ένα παράδειγμα φορητού υπολογιστή SageMaker. Αυτά έρχονται με προεγκατεστημένο το Docker και το χρησιμοποιούμε για να δημιουργήσουμε τα επίπεδα Lambda. Για να ρυθμίσετε την παρουσία του σημειωματάριου, ολοκληρώστε τα ακόλουθα βήματα:
  • Στην κονσόλα SageMaker, δημιουργήστε μια παρουσία σημειωματάριου και δώστε το όνομα του σημειωματάριου, τον τύπο παρουσίας (για αυτήν την ανάρτηση, χρησιμοποιούμε ml.c5.large), το ρόλο IAM και άλλες παραμέτρους.
  • Κλωνοποιήστε το δημόσιο αποθετήριο και προσθέστε το αποθετήριο YOLOv5 παρέχεται από την Ultralytics.

Φιλοξενήστε το YOLOv5 σε ένα τελικό σημείο του SageMaker

Για να μπορέσουμε να φιλοξενήσουμε το προεκπαιδευμένο μοντέλο YOLOv5 στο SageMaker, πρέπει να το εξαγάγουμε και να το συσκευάσουμε στη σωστή δομή καταλόγου μέσα model.tar.gz. Για αυτήν την ανάρτηση, δείχνουμε πώς να φιλοξενήσετε το YOLOv5 στο saved_model μορφή. Το repo 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>"

Στη συνέχεια, μπορούμε να αναπτύξουμε ένα τελικό σημείο SageMaker από ένα σημειωματάριο SageMaker εκτελώντας τον ακόλουθο κώδικα:

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 λεπτά για την πλήρη ανάπτυξη του μοντέλου στο τελικό σημείο του SageMaker. Μπορείτε να παρακολουθείτε την κατάσταση της ανάπτυξης στην κονσόλα SageMaker. Αφού το μοντέλο φιλοξενηθεί με επιτυχία, το μοντέλο είναι έτοιμο για συμπέρασμα.

Δοκιμάστε το τελικό σημείο του SageMaker

Αφού το μοντέλο φιλοξενηθεί με επιτυχία σε ένα τελικό σημείο του SageMaker, μπορούμε να το δοκιμάσουμε, το οποίο κάνουμε χρησιμοποιώντας μια κενή εικόνα. Ο κώδικας δοκιμής είναι ο εξής:

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)

Ρυθμίστε το Lambda με στρώματα και σκανδάλες

Χρησιμοποιούμε το OpenCV για να επιδείξουμε το μοντέλο περνώντας μια εικόνα και λαμβάνοντας τα αποτελέσματα συμπερασμάτων. Το Lambda δεν συνοδεύεται από εξωτερικές βιβλιοθήκες όπως το OpenCV προκατασκευασμένο, επομένως πρέπει να το δημιουργήσουμε για να μπορέσουμε να καλέσουμε τον κώδικα Lambda. Επιπλέον, θέλουμε να διασφαλίσουμε ότι δεν θα δημιουργούμε εξωτερικές βιβλιοθήκες όπως το OpenCV κάθε φορά που γίνεται επίκληση του Lambda. Για το σκοπό αυτό, το Lambda παρέχει μια λειτουργικότητα για τη δημιουργία επιπέδων Lambda. Μπορούμε να ορίσουμε τι συμβαίνει σε αυτά τα επίπεδα και μπορούν να καταναλωθούν από τον κώδικα Lambda κάθε φορά που γίνεται επίκλησή του. Δείχνουμε επίσης πώς να δημιουργήσετε τα επίπεδα Lambda για το OpenCV. Για αυτήν την ανάρτηση, χρησιμοποιούμε ένα Amazon Elastic Compute Cloud (Amazon EC2) παράδειγμα για τη δημιουργία των επιπέδων.

Αφού έχουμε τα στρώματα στη θέση τους, δημιουργούμε το app.py script, που είναι ο κώδικας Lambda που χρησιμοποιεί τα επίπεδα, εκτελεί το συμπέρασμα και λαμβάνει αποτελέσματα. Το παρακάτω διάγραμμα απεικονίζει αυτή τη ροή εργασίας.

Δημιουργήστε επίπεδα Lambda για OpenCV χρησιμοποιώντας το Docker

Χρησιμοποιήστε το Dockerfile ως εξής για να δημιουργήσετε την εικόνα Docker χρησιμοποιώντας την Python 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/

Δημιουργήστε και εκτελέστε το Docker και αποθηκεύστε το αρχείο ZIP εξόδου στον τρέχοντα κατάλογο κάτω από 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 και να δημιουργήσουμε το επίπεδο Lambda:

$ 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

Μετά την επιτυχή εκτέλεση των προηγούμενων εντολών, έχετε ένα επίπεδο OpenCV στο Lambda, το οποίο μπορείτε να ελέγξετε στην κονσόλα Lambda.

Δημιουργήστε τη συνάρτηση Λάμδα

Χρησιμοποιούμε το app.py script για να δημιουργήσετε τη συνάρτηση Lambda και να χρησιμοποιήσετε το 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
                }),
            }

Αναπτύξτε τη συνάρτηση Lambda με τον ακόλουθο κώδικα:

$ 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 στη συνάρτηση Lambda

Αφού έχουμε τη συνάρτηση Lambda και το στρώμα στη θέση τους, μπορούμε να συνδέσουμε το στρώμα στη συνάρτηση ως εξής:

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

Μπορούμε να ελέγξουμε τις ρυθμίσεις του επιπέδου μέσω της κονσόλας Lambda.

Ενεργοποιήστε το Lambda κατά τη μεταφόρτωση μιας εικόνας στο Amazon S3

Χρησιμοποιούμε μια μεταφόρτωση εικόνας στο Amazon S3 ως έναυσμα για την εκτέλεση της συνάρτησης Lambda. Για οδηγίες, ανατρέξτε στο Εκμάθηση: Χρησιμοποιώντας μια σκανδάλη Amazon S3 για να καλέσετε μια συνάρτηση Lambda.

Θα πρέπει να δείτε τις παρακάτω λεπτομέρειες λειτουργίας στην κονσόλα Lambda.

Εκτέλεση συμπερασμάτων

Αφού ρυθμίσετε το Lambda και το τελικό σημείο του SageMaker, μπορείτε να δοκιμάσετε την έξοδο καλώντας τη συνάρτηση Lambda. Χρησιμοποιούμε μια μεταφόρτωση εικόνας στο Amazon S3 ως έναυσμα για να καλέσουμε το Lambda, το οποίο με τη σειρά του καλεί το τελικό σημείο για συμπέρασμα. Για παράδειγμα, ανεβάζουμε την παρακάτω εικόνα στη θέση Amazon S3 <S3 PATH TO IMAGE>/test_image.png διαμορφώθηκε στην προηγούμενη ενότητα.

Μετά τη μεταφόρτωση της εικόνας, ενεργοποιείται η συνάρτηση Lambda για λήψη και ανάγνωση των δεδομένων εικόνας και αποστολή στο τελικό σημείο του SageMaker για συμπέρασμα. Το αποτέλεσμα εξόδου από το τελικό σημείο του SageMaker λαμβάνεται και επιστρέφεται από τη συνάρτηση σε μορφή JSON, την οποία μπορούμε να χρησιμοποιήσουμε με διαφορετικούς τρόπους. Η παρακάτω εικόνα δείχνει παράδειγμα εξόδου που επικαλύπτεται στην εικόνα.

εκκαθάριση

Ανάλογα με τον τύπο του στιγμιότυπου, τα σημειωματάρια SageMaker μπορεί να απαιτούν σημαντική υπολογιστική χρήση και κόστος. Για να αποφύγετε περιττό κόστος, σας συμβουλεύουμε να σταματήσετε την παρουσία του φορητού υπολογιστή όταν δεν χρησιμοποιείται. Επιπλέον, οι συναρτήσεις Lambda και τα τελικά σημεία του SageMaker επιβαρύνονται μόνο με την επίκλησή τους. Επομένως, δεν απαιτείται καθαρισμός για αυτές τις υπηρεσίες. Ωστόσο, εάν ένα τελικό σημείο δεν χρησιμοποιείται πλέον, είναι καλή πρακτική να αφαιρέσετε το τελικό σημείο και το μοντέλο.

Συμπέρασμα

Σε αυτήν την ανάρτηση, δείξαμε πώς μπορείτε να φιλοξενήσετε ένα προεκπαιδευμένο μοντέλο YOLOv5 σε ένα τελικό σημείο του SageMaker και να χρησιμοποιήσετε το Lambda για την επίκληση συμπερασμάτων και την επεξεργασία της εξόδου. Ο αναλυτικός κωδικός είναι διαθέσιμος στο GitHub.

Για να μάθετε περισσότερα σχετικά με τα τελικά σημεία του SageMaker, ρίξτε μια ματιά Δημιουργήστε το τελικό σημείο σας και αναπτύξτε το μοντέλο σας και Δημιουργήστε, δοκιμάστε και αναπτύξτε τα μοντέλα συμπερασμάτων του Amazon SageMaker στο AWS Lambda, το οποίο υπογραμμίζει πώς μπορείτε να αυτοματοποιήσετε τη διαδικασία ανάπτυξης μοντέλων YOLOv5.

Σχετικά με τους συγγραφείς

Κέβιν Σονγκ είναι IoT Edge Data Scientist στην AWS Professional Services. Ο Kevin είναι κάτοχος διδακτορικού στη Βιοφυσική από το Πανεπιστήμιο του Σικάγο. Έχει πάνω από 4 χρόνια εμπειρία στον κλάδο της όρασης υπολογιστών και της μηχανικής μάθησης. Συμμετέχει στο να βοηθά πελάτες στον κλάδο των αθλημάτων και των βιοεπιστημών να αναπτύξουν μοντέλα Machine Learning.

Ρομίλ Σαχ είναι IoT Edge Data Scientist στην AWS Professional Services. Η Romil έχει πάνω από 6 χρόνια εμπειρία στον κλάδο σε συσκευές Computer Vision, Machine Learning και IoT edge. Συμμετέχει στο να βοηθά τους πελάτες να βελτιστοποιήσουν και να αναπτύξουν τα μοντέλα Machine Learning τους για συσκευές αιχμής για βιομηχανική εγκατάσταση.