Schaal YOLOv5-inferentie met Amazon SageMaker-eindpunten en AWS Lambda

Nadat datawetenschappers zorgvuldig een bevredigend machine learning (ML) -model hebben bedacht, moet het model worden ingezet om gemakkelijk toegankelijk te zijn voor gevolgtrekking door andere leden van de organisatie. Het op grote schaal implementeren van modellen met geoptimaliseerde kosten en computerefficiëntie kan echter een ontmoedigende en omslachtige taak zijn. Amazon Sage Maker endpoints bieden een eenvoudig schaalbare en kostengeoptimaliseerde oplossing voor modelimplementatie. Het YOLOv5-model, gedistribueerd onder de GPLv3-licentie, is een populair objectdetectiemodel dat bekend staat om zijn runtime-efficiëntie en detectienauwkeurigheid. In dit bericht laten we zien hoe u een vooraf getraind YOLOv5-model op SageMaker-eindpunten kunt hosten en gebruiken AWS Lambda functies om deze eindpunten aan te roepen.

Overzicht oplossingen

De volgende afbeelding geeft een overzicht van de AWS-services die worden gebruikt om het YOLOv5-model te hosten met behulp van een SageMaker-eindpunt en het eindpunt aan te roepen met Lambda. De SageMaker-notebook heeft toegang tot een YOLOv5 PyTorch-model vanaf een Amazon eenvoudige opslagservice (Amazon S3) emmer, converteert deze naar YOLOv5 TensorFlow SavedModel formaat en slaat het weer op in de S3-bucket. Dit model wordt vervolgens gebruikt bij het hosten van het eindpunt. Wanneer een afbeelding wordt geüpload naar Amazon S3, fungeert deze als een trigger om de Lambda-functie uit te voeren. De functie maakt gebruik van OpenCV Lambda-lagen om de geüploade afbeelding te lezen en inferentie uit te voeren met behulp van het eindpunt. Nadat de inferentie is uitgevoerd, kunt u de daaruit verkregen resultaten naar behoefte gebruiken.

In dit bericht lopen we door het proces van het gebruik van een YOLOv5-standaardmodel in PyTorch en het converteren naar een TensorFlow SavedModel. Dit model wordt gehost met behulp van een SageMaker-eindpunt. Vervolgens maken en publiceren we een Lambda-functie die het eindpunt aanroept om inferentie uit te voeren. Voorgetrainde YOLOv5-modellen zijn beschikbaar op GitHub. Voor het doel van dit bericht gebruiken we de jolov5l model.

Voorwaarden

Als voorwaarde moeten we het volgende instellen: AWS Identiteits- en toegangsbeheer (IAM) rollen met passende toegangsbeleid voor SageMaker, Lambda en Amazon S3:

• SageMaker IAM-rol - Dit vereist AmazonS3FullAccess bijgevoegde beleidsregels voor het opslaan en openen van het model in de S3-bucket
• Lambda IAM-rol – Deze rol heeft meerdere beleidsregels nodig:
  • Om toegang te krijgen tot afbeeldingen die zijn opgeslagen in Amazon S3, hebben we het volgende IAM-beleid nodig:
    • s3:GetObject
    • s3:ListBucket
  • Om het SageMaker-eindpunt uit te voeren, hebben we toegang nodig tot het volgende IAM-beleid:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

U hebt ook de volgende bronnen en services nodig:

• De AWS-opdrachtregelinterface (AWS CLI), die we gebruiken om Lambda te maken en te configureren.
• Een SageMaker-notebookinstantie. Deze worden geleverd met Docker vooraf geïnstalleerd en we gebruiken dit om de Lambda-lagen te maken. Voer de volgende stappen uit om het notebookexemplaar in te stellen:
  • Maak op de SageMaker-console een notebookinstantie en geef de notebooknaam, instantietype (voor dit bericht gebruiken we ml.c5.large), IAM-rol en andere parameters op.
  • Kloon het openbare repository en voeg de YOLOv5-opslagplaats geleverd door Ultralytics.

Host YOLOv5 op een SageMaker-eindpunt

Voordat we het vooraf getrainde YOLOv5-model op SageMaker kunnen hosten, moeten we het exporteren en in de juiste mapstructuur inpakken model.tar.gz. Voor dit bericht laten we zien hoe je YOLOv5 kunt hosten in de saved_model formaat. De YOLOv5-repo biedt een export.py bestand dat het model op veel verschillende manieren kan exporteren. Nadat u de YOLOv5 hebt gekloond en de YOLOv5-map hebt ingevoerd vanaf de opdrachtregel, kunt u het model exporteren met de volgende opdracht:

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

Dit commando maakt een nieuwe map aan met de naam yolov5l_saved_model in de yolov5 map. Binnen in de yolov5l_saved_model directory, zouden we de volgende items moeten zien:

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

Het creëren van een model.tar.gz bestand, verplaats de inhoud van yolov5l_saved_model naar export/Servo/1. Vanaf de opdrachtregel kunnen we de . comprimeren export directory door de volgende opdracht uit te voeren en het model naar de S3-bucket te uploaden:

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

Vervolgens kunnen we een SageMaker-eindpunt implementeren vanuit een SageMaker-notebook door de volgende code uit te voeren:

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)

Het voorgaande script duurt ongeveer 2-3 minuten om het model volledig te implementeren op het SageMaker-eindpunt. U kunt de status van de implementatie volgen op de SageMaker-console. Nadat het model succesvol is gehost, is het model klaar voor inferentie.

Test het SageMaker-eindpunt

Nadat het model met succes is gehost op een SageMaker-eindpunt, kunnen we het testen, wat we doen met een lege afbeelding. De testcode is als volgt:

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 instellen met lagen en triggers

We gebruiken OpenCV om het model te demonstreren door een afbeelding door te geven en de gevolgtrekkingsresultaten te krijgen. Lambda wordt niet geleverd met externe bibliotheken zoals OpenCV vooraf gebouwd, daarom moeten we het bouwen voordat we de Lambda-code kunnen aanroepen. Bovendien willen we ervoor zorgen dat we niet elke keer dat Lambda wordt aangeroepen externe bibliotheken zoals OpenCV bouwen. Voor dit doel biedt Lambda een functionaliteit om Lambda-lagen te maken. We kunnen definiëren wat er in deze lagen komt, en ze kunnen worden geconsumeerd door de Lambda-code elke keer dat deze wordt aangeroepen. We laten ook zien hoe u de Lambda-lagen voor OpenCV kunt maken. Voor dit bericht gebruiken we een Amazon Elastic Compute-cloud (Amazon EC2) instantie om de lagen te maken.

Nadat we de lagen op hun plaats hebben, maken we de app.py script, de Lambda-code die de lagen gebruikt, de gevolgtrekking uitvoert en resultaten krijgt. Het volgende diagram illustreert deze workflow.

Maak Lambda-lagen voor OpenCV met Docker

Gebruik Dockerfile als volgt om de Docker-image te maken met 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/

Bouw en voer Docker uit en sla het output ZIP-bestand op in de huidige map onder 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 kunnen we de OpenCV-laagartefacten uploaden naar Amazon S3 en de Lambda-laag maken:

$ 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

Nadat de voorgaande opdrachten met succes zijn uitgevoerd, hebt u een OpenCV-laag in Lambda, die u kunt bekijken op de Lambda-console.

De Lambda-functie maken

We gebruiken de app.py script om de Lambda-functie te maken en OpenCV te gebruiken. Wijzig in de volgende code de waarden voor BUCKET_NAME en IMAGE_LOCATION naar de locatie voor toegang tot de afbeelding:

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

Implementeer de Lambda-functie met de volgende code:

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

Bevestig de OpenCV-laag aan de Lambda-functie

Nadat we de Lambda-functie en laag op hun plaats hebben, kunnen we de laag als volgt aan de functie verbinden:

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

We kunnen de laaginstellingen bekijken via de Lambda-console.

Activeer Lambda wanneer een afbeelding wordt geüpload naar Amazon S3

We gebruiken een afbeeldingsupload naar Amazon S3 als trigger om de Lambda-functie uit te voeren. Raadpleeg voor instructies: Zelfstudie: Een Amazon S3-trigger gebruiken om een ​​Lambda-functie op te roepen.

U zou de volgende functiedetails op de Lambda-console moeten zien.

Voer gevolgtrekking uit

Nadat u Lambda en het SageMaker-eindpunt hebt ingesteld, kunt u de uitvoer testen door de Lambda-functie aan te roepen. We gebruiken een afbeeldingsupload naar Amazon S3 als een trigger om Lambda aan te roepen, die op zijn beurt het eindpunt voor gevolgtrekking aanroept. Als voorbeeld uploaden we de volgende afbeelding naar de Amazon S3-locatie: <S3 PATH TO IMAGE>/test_image.png geconfigureerd in de vorige sectie.

Nadat de afbeelding is geüpload, wordt de Lambda-functie geactiveerd om de afbeeldingsgegevens te downloaden en te lezen en deze naar het SageMaker-eindpunt te sturen voor gevolgtrekking. Het uitvoerresultaat van het SageMaker-eindpunt wordt verkregen en geretourneerd door de functie in JSON-indeling, die we op verschillende manieren kunnen gebruiken. De volgende afbeelding toont voorbeelduitvoer die over de afbeelding is gelegd.

Opruimen

Afhankelijk van het instantietype kunnen SageMaker-notebooks aanzienlijk rekengebruik en -kosten vergen. Om onnodige kosten te voorkomen, raden we aan om de notebook-instantie te stoppen wanneer deze niet in gebruik is. Bovendien brengen Lambda-functies en SageMaker-eindpunten alleen kosten in rekening wanneer ze worden aangeroepen. Daarom is er voor deze services geen opschoning nodig. Als een eindpunt echter niet meer wordt gebruikt, is het een goede gewoonte om het eindpunt en het model te verwijderen.

Conclusie

In dit bericht hebben we laten zien hoe je een vooraf getraind YOLOv5-model host op een SageMaker-eindpunt en Lambda gebruikt om gevolgtrekkingen op te roepen en de uitvoer te verwerken. De gedetailleerde code is beschikbaar op: GitHub.

Ga voor meer informatie over SageMaker-eindpunten naar Maak uw eindpunt en implementeer uw model en Bouw, test en implementeer uw Amazon SageMaker-inferentiemodellen voor AWS Lambda, waarin wordt uitgelegd hoe u het implementatieproces van YOLOv5-modellen kunt automatiseren.

Over de auteurs

Kevin Lied is een IoT Edge Data Scientist bij AWS Professional Services. Kevin is gepromoveerd in biofysica aan de Universiteit van Chicago. Hij heeft meer dan 4 jaar ervaring in de industrie in Computer Vision en Machine Learning. Hij is betrokken bij het helpen van klanten in de sport- en life sciences-industrie bij het implementeren van Machine Learning-modellen.

Romil Sjah is een IoT Edge Data Scientist bij AWS Professional Services. Romil heeft meer dan 6 jaar ervaring in de sector in Computer Vision, Machine Learning en IoT edge-apparaten. Hij is betrokken bij het helpen van klanten bij het optimaliseren en implementeren van hun Machine Learning-modellen voor edge-apparaten voor industriële instellingen.