Scalați inferența YOLOv5 cu punctele finale Amazon SageMaker și AWS Lambda

După ce oamenii de știință de date vin cu atenție cu un model satisfăcător de învățare automată (ML), modelul trebuie să fie implementat pentru a fi ușor accesibil pentru inferență de către alți membri ai organizației. Cu toate acestea, implementarea modelelor la scară cu costuri optimizate și eficiență de calcul poate fi o sarcină descurajantă și greoaie. Amazon SageMaker punctele finale oferă o soluție ușor scalabilă și optimizată din punct de vedere al costurilor pentru implementarea modelului. Modelul YOLOv5, distribuit sub licența GPLv3, este un model popular de detectare a obiectelor cunoscut pentru eficiența de rulare, precum și pentru acuratețea detectării. În această postare, demonstrăm cum să găzduim un model YOLOv5 pre-antrenat pe punctele finale SageMaker și să folosim AWS Lambdas funcții pentru a invoca aceste puncte finale.

Prezentare generală a soluțiilor

Următoarea imagine prezintă serviciile AWS utilizate pentru a găzdui modelul YOLOv5 utilizând un punct final SageMaker și pentru a invoca punctul final utilizând Lambda. Notebook-ul SageMaker accesează un model YOLOv5 PyTorch dintr-un Serviciul Amazon de stocare simplă (Amazon S3), îl convertește în YOLOv5 TensorFlow SavedModel format și îl stochează înapoi în compartimentul S3. Acest model este apoi utilizat atunci când găzduiește punctul final. Când o imagine este încărcată pe Amazon S3, aceasta acționează ca un declanșator pentru a rula funcția Lambda. Funcția utilizează OpenCV Straturi lambda pentru a citi imaginea încărcată și a rula inferența folosind punctul final. După rularea inferenței, puteți utiliza rezultatele obținute din aceasta după cum este necesar.

În această postare, parcurgem procesul de utilizare a unui model implicit YOLOv5 în PyTorch și de conversie a acestuia într-un TensorFlow SavedModel. Acest model este găzduit folosind un punct final SageMaker. Apoi creăm și publicăm o funcție Lambda care invocă punctul final pentru a rula inferența. Modelele YOLOv5 pre-antrenate sunt disponibile pe GitHub. În scopul acestei postări, folosim yolov5l model.

Cerințe preliminare

Ca o condiție prealabilă, trebuie să setăm următoarele Gestionarea identității și accesului AWS (IAM) cu roluri adecvate politici de acces pentru SageMaker, Lambda și Amazon S3:

• Rolul IAM SageMaker - Este nevoie de AmazonS3FullAccess politici atașate pentru stocarea și accesarea modelului în compartimentul S3
• Rolul Lambda IAM – Acest rol necesită mai multe politici:
  • Pentru a accesa imaginile stocate în Amazon S3, avem nevoie de următoarele politici IAM:
    • s3:GetObject
    • s3:ListBucket
  • Pentru a rula punctul final SageMaker, avem nevoie de acces la următoarele politici IAM:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

De asemenea, aveți nevoie de următoarele resurse și servicii:

• Interfața liniei de comandă AWS (AWS CLI), pe care îl folosim pentru a crea și configura Lambda.
• O instanță de notebook SageMaker. Acestea vin cu Docker preinstalat și îl folosim pentru a crea straturi Lambda. Pentru a configura instanța de notebook, parcurgeți următorii pași:
  • Pe consola SageMaker, creați o instanță de blocnotes și furnizați numele blocnotesului, tipul instanței (pentru această postare, folosim ml.c5.large), rolul IAM și alți parametri.
  • Clonați depozit public și adăugați Depozitul YOLOv5 oferit de Ultralytics.

Găzduiește YOLOv5 pe un punct final SageMaker

Înainte de a putea găzdui modelul YOLOv5 pre-antrenat pe SageMaker, trebuie să-l exportăm și să-l ambalăm în structura corectă de directoare din interior model.tar.gz. Pentru această postare, demonstrăm cum să găzduiești YOLOv5 în saved_model format. Repo YOLOv5 oferă un export.py fișier care poate exporta modelul în multe moduri diferite. După ce clonați YOLOv5 și introduceți directorul YOLOv5 din linia de comandă, puteți exporta modelul cu următoarea comandă:

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

Această comandă creează un nou director numit yolov5l_saved_model în interiorul yolov5 director. În interiorul yolov5l_saved_model director, ar trebui să vedem următoarele elemente:

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

Pentru a crea un model.tar.gz fișier, mutați conținutul yolov5l_saved_model la export/Servo/1. Din linia de comandă, putem comprima export directorul rulând următoarea comandă și încărcând modelul în compartimentul 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>"

Apoi, putem implementa un punct final SageMaker dintr-un notebook SageMaker rulând următorul cod:

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)

Scriptul precedent durează aproximativ 2-3 minute pentru a implementa complet modelul la punctul final SageMaker. Puteți monitoriza starea implementării pe consola SageMaker. După ce modelul este găzduit cu succes, modelul este gata pentru inferență.

Testați punctul final SageMaker

După ce modelul este găzduit cu succes pe un punct final SageMaker, îl putem testa, ceea ce facem folosind o imagine goală. Codul de testare este următorul:

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)

Configurați Lambda cu straturi și declanșatoare

Folosim OpenCV pentru a demonstra modelul prin trecerea unei imagini și obținerea rezultatelor inferenței. Lambda nu vine cu biblioteci externe precum OpenCV pre-construite, prin urmare trebuie să-l construim înainte de a putea invoca codul Lambda. În plus, vrem să ne asigurăm că nu construim biblioteci externe precum OpenCV de fiecare dată când Lambda este invocat. În acest scop, Lambda oferă o funcționalitate pentru a crea straturi Lambda. Putem defini ce se întâmplă în aceste straturi și ele pot fi consumate de codul Lambda de fiecare dată când este invocat. De asemenea, demonstrăm cum să creați straturile Lambda pentru OpenCV. Pentru această postare, folosim un Cloud Elastic de calcul Amazon (Amazon EC2) pentru a crea straturile.

După ce avem straturile la locul lor, creăm app.py scriptul, care este codul Lambda care utilizează straturile, rulează inferența și obține rezultate. Următoarea diagramă ilustrează acest flux de lucru.

Creați straturi Lambda pentru OpenCV folosind Docker

Utilizați Dockerfile după cum urmează pentru a crea imaginea Docker folosind 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/

Construiți și rulați Docker și stocați fișierul ZIP de ieșire în directorul curent sub 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

Acum putem încărca artefactele stratului OpenCV pe Amazon S3 și putem crea stratul 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

După ce comenzile precedente rulează cu succes, aveți un strat OpenCV în Lambda, pe care îl puteți revizui pe consola Lambda.

Creați funcția Lambda

Noi folosim app.py script pentru a crea funcția Lambda și a utiliza OpenCV. În următorul cod, modificați valorile pentru BUCKET_NAME și IMAGE_LOCATION la locația de accesare a imaginii:

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

Implementați funcția Lambda cu următorul cod:

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

Atașați stratul OpenCV la funcția Lambda

După ce avem funcția Lambda și stratul la locul lor, putem conecta stratul la funcție după cum urmează:

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

Putem revizui setările stratului prin consola Lambda.

Declanșați Lambda atunci când o imagine este încărcată pe Amazon S3

Folosim o imagine încărcată pe Amazon S3 ca declanșator pentru a rula funcția Lambda. Pentru instrucțiuni, consultați Tutorial: Utilizarea unui declanșator Amazon S3 pentru a invoca o funcție Lambda.

Ar trebui să vedeți următoarele detalii ale funcției pe consola Lambda.

Executați inferența

După ce ați configurat Lambda și punctul final SageMaker, puteți testa rezultatul invocând funcția Lambda. Folosim o imagine încărcată pe Amazon S3 ca declanșator pentru a invoca Lambda, care la rândul său invocă punctul final pentru inferență. Ca exemplu, încărcăm următoarea imagine în locația Amazon S3 <S3 PATH TO IMAGE>/test_image.png configurat în secțiunea anterioară.

După ce imaginea este încărcată, funcția Lambda este declanșată pentru a descărca și a citi datele imaginii și a le trimite la punctul final SageMaker pentru deducere. Rezultatul de ieșire de la punctul final SageMaker este obținut și returnat de funcția în format JSON, pe care o putem folosi în diferite moduri. Următoarea imagine prezintă un exemplu de ieșire suprapusă pe imagine.

A curăța

În funcție de tipul de instanță, notebook-urile SageMaker pot necesita o utilizare și un cost semnificativ de calcul. Pentru a evita costurile inutile, vă sfătuim să opriți instanța de notebook atunci când nu este utilizată. În plus, funcțiile Lambda și punctele finale SageMaker suportă taxe numai atunci când sunt invocate. Prin urmare, nu este necesară nicio curățare pentru aceste servicii. Cu toate acestea, dacă un punct final nu mai este utilizat, este o practică bună să eliminați punctul final și modelul.

Concluzie

În această postare, am demonstrat cum să găzduim un model YOLOv5 pre-antrenat pe un punct final SageMaker și să folosim Lambda pentru a invoca inferența și a procesa rezultatul. Codul detaliat este disponibil pe GitHub.

Pentru a afla mai multe despre punctele finale SageMaker, consultați Creați punctul final și implementați modelul și Creați, testați și implementați modelele dvs. de inferență Amazon SageMaker în AWS Lambda, care evidențiază modul în care puteți automatiza procesul de implementare a modelelor YOLOv5.

Despre autori

Kevin Song este IoT Edge Data Scientist la AWS Professional Services. Kevin deține un doctorat în biofizică de la Universitatea din Chicago. Are peste 4 ani de experiență în industrie în viziunea computerizată și învățarea automată. El este implicat în a ajuta clienții din industria sportului și științelor vieții să implementeze modele de învățare automată.

Romil Shah este IoT Edge Data Scientist la AWS Professional Services. Romil are peste 6 ani de experiență în industrie în computer Vision, Machine Learning și dispozitive edge IoT. El este implicat în a ajuta clienții să optimizeze și să implementeze modelele lor de învățare automată pentru dispozitive de vârf pentru configurarea industrială.