Skaler YOLOv5-inferens med Amazon SageMaker-endepunkter og AWS Lambda

Efter at dataforskere omhyggeligt har fundet frem til en tilfredsstillende maskinlæringsmodel (ML), skal modellen implementeres for at være let tilgængelig for andre medlemmer af organisationen. Det kan dog være en skræmmende og besværlig opgave at implementere modeller i skala med optimeret omkostnings- og computereffektivitet. Amazon SageMaker endepunkter giver en let skalerbar og omkostningsoptimeret løsning til modelimplementering. YOLOv5-modellen, distribueret under GPLv3-licensen, er en populær objektdetekteringsmodel kendt for sin køretidseffektivitet samt detektionsnøjagtighed. I dette indlæg demonstrerer vi, hvordan man hoster en præ-trænet YOLOv5-model på SageMaker-slutpunkter og bruger AWS Lambda funktioner til at påkalde disse endepunkter.

Løsningsoversigt

Følgende billede skitserer de AWS-tjenester, der bruges til at være vært for YOLOv5-modellen ved hjælp af et SageMaker-slutpunkt og kalde slutpunktet ved hjælp af Lambda. SageMaker-notebooken får adgang til en YOLOv5 PyTorch-model fra en Amazon Simple Storage Service (Amazon S3) spand, konverterer den til YOLOv5 TensorFlow SavedModel format, og gemmer det tilbage i S3-bøtten. Denne model bruges så til hosting af slutpunktet. Når et billede uploades til Amazon S3, fungerer det som en trigger til at køre Lambda-funktionen. Funktionen bruger OpenCV Lambda lag for at læse det uploadede billede og køre inferens ved hjælp af slutpunktet. Efter slutningen er kørt, kan du bruge resultaterne opnået fra den efter behov.

I dette indlæg gennemgår vi processen med at bruge en YOLOv5 standardmodel i PyTorch og konvertere den til en TensorFlow SavedModel. Denne model hostes ved hjælp af et SageMaker-slutpunkt. Derefter opretter og udgiver vi en Lambda-funktion, der kalder slutpunktet til at køre inferens. Foruddannede YOLOv5-modeller er tilgængelige på GitHub. Til formålet med dette indlæg bruger vi yolov5l model.

Forudsætninger

Som en forudsætning skal vi opsætte følgende AWS identitets- og adgangsstyring (IAM) roller med passende adgangspolitikker til SageMaker, Lambda og Amazon S3:

• SageMaker IAM rolle – Det kræver AmazonS3FullAccess vedhæftede politikker for opbevaring og adgang til modellen i S3-spanden
• Lambda IAM rolle – Denne rolle kræver flere politikker:
  • For at få adgang til billeder gemt i Amazon S3 kræver vi følgende IAM-politikker:
    • s3:GetObject
    • s3:ListBucket
  • For at køre SageMaker-slutpunktet skal vi have adgang til følgende IAM-politikker:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

Du har også brug for følgende ressourcer og tjenester:

• AWS kommandolinjegrænseflade (AWS CLI), som vi bruger til at oprette og konfigurere Lambda.
• En SageMaker notebook-forekomst. Disse kommer med Docker forudinstalleret, og vi bruger dette til at skabe Lambda-lagene. For at konfigurere notebook-forekomsten skal du udføre følgende trin:
  • På SageMaker-konsollen skal du oprette en notesbogsforekomst og angive notebooknavnet, forekomsttypen (til dette indlæg bruger vi ml.c5.large), IAM-rollen og andre parametre.
  • Klon offentligt depot og tilføj YOLOv5-depot leveret af Ultralytics.

Vær vært for YOLOv5 på et SageMaker-slutpunkt

Før vi kan hoste den fortrænede YOLOv5-model på SageMaker, skal vi eksportere og pakke den i den korrekte mappestruktur inde model.tar.gz. Til dette indlæg demonstrerer vi, hvordan man hoster YOLOv5 i saved_model format. YOLOv5 repo giver en export.py fil, der kan eksportere modellen på mange forskellige måder. Når du har klonet YOLOv5 og indtastet YOLOv5-mappen fra kommandolinjen, kan du eksportere modellen med følgende kommando:

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

Denne kommando opretter en ny mappe kaldet yolov5l_saved_model Inde i yolov5 vejviser. Inde i yolov5l_saved_model mappe, bør vi se følgende elementer:

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

At oprette en model.tar.gz fil, skal du flytte indholdet af yolov5l_saved_model til export/Servo/1. Fra kommandolinjen kan vi komprimere export mappe ved at køre følgende kommando og uploade modellen til S3-bøtten:

$ 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>"

Derefter kan vi implementere et SageMaker-slutpunkt fra en SageMaker-notesbog ved at køre følgende kode:

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)

Det foregående script tager cirka 2-3 minutter at implementere modellen fuldt ud til SageMaker-slutpunktet. Du kan overvåge status for implementeringen på SageMaker-konsollen. Efter at modellen er hostet med succes, er modellen klar til slutning.

Test SageMaker-endepunktet

Efter at modellen er hostet på et SageMaker-slutpunkt, kan vi teste det, hvilket vi gør ved hjælp af et tomt billede. Testkoden er som følger:

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)

Opsæt Lambda med lag og triggere

Vi bruger OpenCV til at demonstrere modellen ved at sende et billede og få slutningsresultaterne. Lambda kommer ikke med eksterne biblioteker som OpenCV pre-built, derfor er vi nødt til at bygge det, før vi kan kalde Lambda-koden. Desuden vil vi sikre os, at vi ikke bygger eksterne biblioteker som OpenCV, hver gang Lambda bliver påkaldt. Til dette formål giver Lambda en funktionalitet til at skabe Lambda-lag. Vi kan definere, hvad der skal i disse lag, og de kan forbruges af Lambda-koden, hver gang den påkaldes. Vi demonstrerer også, hvordan man opretter Lambda-lagene til OpenCV. Til dette indlæg bruger vi en Amazon Elastic Compute Cloud (Amazon EC2) forekomst for at oprette lagene.

Efter at vi har lagt lagene på plads, skaber vi app.py script, som er Lambda-koden, der bruger lagene, kører inferensen og får resultater. Følgende diagram illustrerer denne arbejdsgang.

Opret Lambda-lag til OpenCV ved hjælp af Docker

Brug Dockerfile som følger til at oprette Docker-billedet ved hjælp af 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/

Byg og kør Docker og gem output ZIP-filen i den aktuelle mappe under 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

Nu kan vi uploade OpenCV-lagartefakter til Amazon S3 og oprette Lambda-laget:

$ 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

Efter at de foregående kommandoer er kørt med succes, har du et OpenCV-lag i Lambda, som du kan gennemgå på Lambda-konsollen.

Opret Lambda-funktionen

Vi bruger app.py script til at oprette Lambda-funktionen og bruge OpenCV. I den følgende kode skal du ændre værdierne for BUCKET_NAME , IMAGE_LOCATION til stedet for at få adgang til billedet:

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
                }),
            }

Implementer Lambda-funktionen med følgende kode:

$ 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>"

Vedhæft OpenCV-laget til Lambda-funktionen

Når vi har fået Lambda-funktionen og laget på plads, kan vi forbinde laget med funktionen som følger:

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

Vi kan gennemgå lagindstillingerne via Lambda-konsollen.

Udløs Lambda, når et billede uploades til Amazon S3

Vi bruger en billedupload til Amazon S3 som en trigger til at køre Lambda-funktionen. For instruktioner, se Selvstudium: Brug af en Amazon S3-trigger til at starte en Lambda-funktion.

Du bør se følgende funktionsdetaljer på Lambda-konsollen.

Kør inferens

Når du har konfigureret Lambda og SageMaker-slutpunktet, kan du teste outputtet ved at aktivere Lambda-funktionen. Vi bruger en billedupload til Amazon S3 som en trigger til at påkalde Lambda, som igen påkalder slutpunktet for inferens. Som et eksempel uploader vi følgende billede til Amazon S3-lokationen <S3 PATH TO IMAGE>/test_image.png konfigureret i forrige afsnit.

Efter at billedet er uploadet, udløses Lambda-funktionen for at downloade og læse billeddataene og sende dem til SageMaker-slutpunktet til slutning. Outputresultatet fra SageMaker-slutpunktet opnås og returneres af funktionen i JSON-format, som vi kan bruge på forskellige måder. Følgende billede viser et eksempel på output overlejret på billedet.

Ryd op

Afhængigt af instanstypen kan SageMaker-notebooks kræve betydeligt computerforbrug og -omkostninger. For at undgå unødvendige omkostninger anbefaler vi, at du stopper notebook-forekomsten, når den ikke er i brug. Derudover pålægges Lambda-funktioner og SageMaker-slutpunkter kun gebyrer, når de aktiveres. Derfor er der ikke behov for oprydning for disse tjenester. Men hvis et endepunkt ikke længere bruges, er det god praksis at fjerne endepunktet og modellen.

Konklusion

I dette indlæg demonstrerede vi, hvordan man hoster en forudtrænet YOLOv5-model på et SageMaker-slutpunkt og bruger Lambda til at påkalde slutninger og behandle outputtet. Den detaljerede kode er tilgængelig på GitHub.

For at lære mere om SageMaker-endepunkter, tjek ud Opret dit slutpunkt og implementer din model , Byg, test og implementer dine Amazon SageMaker-inferensmodeller til AWS Lambda, som fremhæver, hvordan du kan automatisere processen med at implementere YOLOv5-modeller.

Om forfatterne

Kevin sang er IoT Edge Data Scientist hos AWS Professional Services. Kevin har en PhD i biofysik fra University of Chicago. Han har over 4 års brancheerfaring inden for computersyn og maskinlæring. Han er involveret i at hjælpe kunder i sports- og biovidenskabsindustrien med at implementere Machine Learning-modeller.

Romil Shah er IoT Edge Data Scientist hos AWS Professional Services. Romil har over 6 års brancheerfaring inden for Computer Vision, Machine Learning og IoT edge-enheder. Han er involveret i at hjælpe kunder med at optimere og implementere deres Machine Learning-modeller til edge-enheder til industriel opsætning.