Mérje fel a YOLOv5 következtetést az Amazon SageMaker végpontjaival és az AWS Lambdával

Miután az adattudósok gondosan kidolgoztak egy kielégítő gépi tanulási (ML) modellt, a modellt úgy kell telepíteni, hogy a szervezet többi tagja könnyen hozzáférhessen ahhoz, hogy következtetéseket lehessen levonni. Az optimalizált költség- és számítási hatékonyságú modellek méretarányos üzembe helyezése azonban ijesztő és nehézkes feladat lehet. Amazon SageMaker végpontok könnyen méretezhető és költségoptimalizált megoldást kínálnak a modellek telepítéséhez. A GPLv5 licenc alatt terjesztett YOLOv3 modell egy népszerű objektumészlelési modell, amely futásidejű hatékonyságáról és észlelési pontosságáról ismert. Ebben a bejegyzésben bemutatjuk, hogyan lehet egy előre betanított YOLOv5 modellt a SageMaker végpontokon tárolni és AWS Lambda függvények ezeknek a végpontoknak a meghívásához.

Megoldás áttekintése

A következő kép felvázolja a YOLOv5-modell SageMaker-végpont használatával történő üzemeltetéséhez és a végpont Lambda használatával történő meghívásához használt AWS-szolgáltatásokat. A SageMaker notebook egy YOLOv5 PyTorch modellt ér el egy Amazon egyszerű tárolási szolgáltatás (Amazon S3) vödör, átalakítja YOLOv5 TensorFlow-ra SavedModel formátumban, és visszatárolja az S3 vödörbe. Ezt a modellt ezután a végpont tárolásakor használják. Amikor egy képet feltöltenek az Amazon S3-ra, az aktiválja a Lambda funkciót. A funkció OpenCV-t használ Lambda rétegek a feltöltött kép elolvasásához és a végpont segítségével következtetés lefuttatásához. A következtetés lefuttatása után szükség szerint felhasználhatja az abból kapott eredményeket.

Ebben a bejegyzésben végigjárjuk a YOLOv5 alapértelmezett modelljének PyTorch alkalmazásának és TensorFlow-vá alakításának folyamatát. SavedModel. Ezt a modellt egy SageMaker-végpont tárolja. Ezután létrehozunk és közzéteszünk egy Lambda függvényt, amely meghívja a végpontot a következtetés futtatásához. Az előre betanított YOLOv5 modellek a következő helyen érhetők el GitHub. Jelen bejegyzés céljaira a yolov5l modell.

Előfeltételek

Előfeltételként a következőket kell beállítanunk AWS Identity and Access Management (IAM) szerepek megfelelő hozzáférési szabályzatok SageMaker, Lambda és Amazon S3 esetében:

• SageMaker IAM szerepkör – Ez megköveteli AmazonS3FullAccess a modell S3 tárolóban való tárolására és elérésére vonatkozó irányelveket csatoltak
• Lambda IAM szerepe – Ehhez a szerepkörhöz többféle szabályzat szükséges:
  • Az Amazon S3-ban tárolt képek eléréséhez a következő IAM-szabályzatra van szükségünk:
    • s3:GetObject
    • s3:ListBucket
  • A SageMaker végpont futtatásához hozzá kell férnünk a következő IAM-házirendekhez:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

Ezenkívül a következő erőforrásokra és szolgáltatásokra van szüksége:

• A AWS parancssori interfész (AWS CLI), amelyet a Lambda létrehozására és konfigurálására használunk.
• Egy SageMaker notebook példány. Ezek a Docker előre telepítve vannak, és ezt használjuk a Lambda rétegek létrehozásához. A notebook példány beállításához hajtsa végre a következő lépéseket:
  • A SageMaker konzolon hozzon létre egy jegyzetfüzet-példányt, és adja meg a jegyzetfüzet nevét, példánytípusát (ebben a bejegyzésben az ml.c5.large-t használjuk), az IAM-szerepet és egyéb paramétereket.
  • Klónozza a nyilvános adattár és adjuk hozzá a YOLOv5 adattár az Ultralytics biztosítja.

Hozd a YOLOv5-öt egy SageMaker-végponton

Mielőtt tárolhatnánk az előre betanított YOLOv5 modellt a SageMakeren, exportálnunk kell és be kell csomagolnunk a megfelelő könyvtárszerkezetbe. model.tar.gz. Ebben a bejegyzésben bemutatjuk, hogyan lehet tárolni a YOLOv5-öt a saved_model formátum. A YOLOv5 repo egy export.py fájl, amely sokféle módon exportálhatja a modellt. Miután klónozta a YOLOv5-öt és belépett a YOLOv5 könyvtárba a parancssorból, exportálhatja a modellt a következő paranccsal:

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

Ez a parancs egy új könyvtárat hoz létre yolov5l_saved_model belül yolov5 Könyvtár. Benne yolov5l_saved_model könyvtárban a következő elemeket kell látnunk:

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

A model.tar.gz fájlt, mozgassa át a tartalmát yolov5l_saved_model nak nek export/Servo/1. A parancssorból tömöríthetjük a export könyvtárba a következő parancs futtatásával, és töltse fel a modellt az S3 tárolóba:

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

Ezután a következő kód futtatásával telepíthetünk egy SageMaker végpontot egy SageMaker notebookból:

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)

Az előző szkript körülbelül 2–3 percet vesz igénybe a modell teljes üzembe helyezése a SageMaker végponton. A SageMaker konzolon nyomon követheti a telepítés állapotát. A modell sikeres hosztolása után a modell készen áll a következtetésre.

Tesztelje a SageMaker végpontot

Miután a modellt sikeresen hosztoltuk egy SageMaker végponton, kipróbálhatjuk, amit egy üres kép használatával teszünk meg. A tesztelési kód a következő:

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)

Állítsa be a Lambdát rétegekkel és triggerekkel

OpenCV-t használunk a modell bemutatására egy kép átadásával és a következtetések lekérésével. A Lambda nem tartalmaz olyan külső könyvtárakat, mint az előre beépített OpenCV, ezért a Lambda kód meghívása előtt meg kell építenünk. Továbbá biztosítani szeretnénk, hogy ne építsünk külső könyvtárakat, például az OpenCV-t minden alkalommal, amikor a Lambdát meghívják. Erre a célra a Lambda funkciót biztosít Lambda rétegek létrehozására. Meghatározhatjuk, hogy mi kerüljön ezekbe a rétegekbe, és a Lambda kód minden alkalommal felhasználhatja őket, amikor meghívják. Azt is bemutatjuk, hogyan kell létrehozni a Lambda rétegeket az OpenCV számára. Ehhez a bejegyzéshez egy Amazon rugalmas számítási felhő (Amazon EC2) példányt a rétegek létrehozásához.

Miután a rétegek a helyükre kerültek, létrehozzuk a app.py script, amely a Lambda kód, amely a rétegeket használja, lefuttatja a következtetést, és eredményt kap. A következő diagram ezt a munkafolyamatot mutatja be.

Hozzon létre Lambda rétegeket az OpenCV számára a Docker segítségével

Használja a Dockerfile-t az alábbiak szerint a Docker-kép létrehozásához a Python 3.7 használatával:

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/

Építse és futtassa a Dockert, és tárolja a kimeneti ZIP-fájlt az aktuális könyvtárban 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

Most feltölthetjük az OpenCV réteg műtermékeit az Amazon S3-ra, és létrehozhatjuk a Lambda réteget:

$ 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

Miután az előző parancsok sikeresen lefutottak, van egy OpenCV rétege a Lambdában, amelyet a Lambda konzolon tekinthet meg.

Hozd létre a Lambda függvényt

Használjuk a app.py szkriptet a Lambda függvény létrehozásához és az OpenCV használatához. A következő kódban módosítsa az értékeit BUCKET_NAME és a IMAGE_LOCATION a kép elérési helyére:

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

Telepítse a Lambda funkciót a következő kóddal:

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

Csatlakoztassa az OpenCV réteget a Lambda függvényhez

Miután a Lambda függvény és a réteg a helyére került, a réteget a következőképpen csatlakoztathatjuk a függvényhez:

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

A rétegbeállításokat a Lambda konzolon keresztül tekinthetjük át.

A Lambda aktiválása, ha egy képet feltöltenek az Amazon S3-ra

A Lambda funkció futtatásához egy képfeltöltést használunk az Amazon S3-ba. Az utasításokat lásd Oktatóanyag: Amazon S3 trigger használata Lambda függvény meghívására.

A következő funkciók részleteit kell látnia a Lambda konzolon.

Következtetés futtatása

A Lambda és a SageMaker végpont beállítása után tesztelheti a kimenetet a Lambda függvény meghívásával. Az Amazon S3-ba való képfeltöltést használjuk triggerként a Lambda meghívásához, amely viszont a végpontot hívja meg következtetés céljából. Példaként feltöltjük a következő képet az Amazon S3 helyére <S3 PATH TO IMAGE>/test_image.png az előző részben konfigurálva.

A kép feltöltése után a Lambda funkció aktiválódik a képadatok letöltéséhez és olvasásához, majd elküldi azokat a SageMaker végpontnak következtetés céljából. A SageMaker végpont kimeneti eredményét a függvény kapja meg és adja vissza JSON formátumban, amelyet többféleképpen használhatunk. A következő kép a képre ráborított példa kimenetet mutat be.

Tisztítsuk meg

A példány típusától függően a SageMaker notebookok jelentős számítási felhasználást és költségeket igényelhetnek. A szükségtelen költségek elkerülése érdekében javasoljuk, hogy állítsa le a notebook példányt, amikor nem használja. Ezenkívül a Lambda-függvények és a SageMaker-végpontok csak akkor számítanak fel költségeket, ha meghívják őket. Ezért ezeknél a szolgáltatásoknál nincs szükség tisztításra. Ha azonban egy végpont már nincs használatban, célszerű eltávolítani a végpontot és a modellt.

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan lehet egy előre betanított YOLOv5 modellt egy SageMaker-végponton tárolni, és hogyan lehet a Lambdát a következtetések lehívására és a kimenet feldolgozására használni. A részletes kód elérhető a GitHub.

Ha többet szeretne megtudni a SageMaker végpontjairól, nézze meg Hozza létre a végpontot, és helyezze üzembe a modellt és a Építse meg, tesztelje és telepítse Amazon SageMaker következtetési modelljeit az AWS Lambdára, amely rávilágít arra, hogyan automatizálhatja a YOLOv5 modellek üzembe helyezésének folyamatát.

A szerzőkről

Kevin Song az IoT Edge Data Scientist az AWS Professional Servicesnél. Kevin a Chicagói Egyetemen szerzett PhD fokozatot biofizikából. Több mint 4 éves iparági tapasztalattal rendelkezik a Computer Vision és a Machine Learning területén. Részt vesz a sport- és élettudományi ipar ügyfelei számára a gépi tanulási modellek bevezetésében.

Romil Shah az IoT Edge Data Scientist az AWS Professional Servicesnél. Romil több mint 6 éves iparági tapasztalattal rendelkezik a Computer Vision, a Machine Learning és az IoT edge eszközök terén. Részt vesz abban, hogy segítse az ügyfeleket gépi tanulási modelljeik optimalizálásában és üzembe helyezésében az ipari telepítéshez szükséges éleszközökhöz.