Skaluj wnioskowanie YOLOv5 z punktami końcowymi Amazon SageMaker i AWS Lambda

Po dokładnym opracowaniu przez analityków danych satysfakcjonującego modelu uczenia maszynowego (ML), model musi zostać wdrożony, aby był łatwo dostępny do wnioskowania dla innych członków organizacji. Jednak wdrażanie modeli na dużą skalę przy zoptymalizowanych kosztach i wydajnościach obliczeniowych może być trudnym i uciążliwym zadaniem. Amazon Sage Maker punkty końcowe zapewniają łatwo skalowalne i zoptymalizowane pod względem kosztów rozwiązanie do wdrażania modeli. Model YOLOv5, dystrybuowany na licencji GPLv3, jest popularnym modelem wykrywania obiektów znanym ze swojej wydajności w czasie wykonywania, a także dokładności wykrywania. W tym poście pokazujemy, jak hostować wstępnie wytrenowany model YOLOv5 na punktach końcowych SageMaker i używać AWS Lambda funkcje do wywoływania tych punktów końcowych.

Omówienie rozwiązania

Poniższy obraz przedstawia usługi AWS używane do hostowania modelu YOLOv5 przy użyciu punktu końcowego SageMaker i wywoływania punktu końcowego przy użyciu Lambda. Notatnik SageMaker uzyskuje dostęp do modelu YOLOv5 PyTorch od Usługa Amazon Simple Storage (Amazon S3), zamienia go na YOLOv5 TensorFlow SavedModel i przechowuje go z powrotem w zasobniku S3. Ten model jest następnie używany podczas hostowania punktu końcowego. Gdy obraz jest przesyłany do Amazon S3, działa jako wyzwalacz do uruchomienia funkcji Lambda. Funkcja wykorzystuje OpenCV Warstwy lambda aby odczytać przesłany obraz i uruchomić wnioskowanie przy użyciu punktu końcowego. Po przeprowadzeniu wnioskowania możesz w razie potrzeby wykorzystać uzyskane z niego wyniki.

W tym poście opisujemy proces wykorzystania domyślnego modelu YOLOv5 w PyTorch i przekonwertowania go na TensorFlow SavedModel. Ten model jest hostowany przy użyciu punktu końcowego SageMaker. Następnie tworzymy i publikujemy funkcję Lambda, która wywołuje punkt końcowy w celu uruchomienia wnioskowania. Wstępnie przeszkolone modele YOLOv5 są dostępne na GitHub. Na potrzeby tego posta używamy yolov5l model.

Wymagania wstępne

Jako warunek wstępny musimy skonfigurować następujące AWS Zarządzanie tożsamością i dostępem (IAM) role z odpowiednimi zasady dostępu dla SageMaker, Lambda i Amazon S3:

• Rola uprawnień SageMakera - To wymaga AmazonS3FullAccess zasady dołączone do przechowywania i uzyskiwania dostępu do modelu w zasobniku S3
• Rola Lambda IAM – Ta rola wymaga wielu polityk:
  • Aby uzyskać dostęp do obrazów przechowywanych w Amazon S3, wymagamy następujących zasad uprawnień:
    • s3:GetObject
    • s3:ListBucket
  • Aby uruchomić punkt końcowy SageMaker, potrzebujemy dostępu do następujących zasad uprawnień:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

Potrzebujesz również następujących zasobów i usług:

• Połączenia Interfejs wiersza poleceń AWS (AWS CLI), którego używamy do tworzenia i konfiguracji Lambdy.
• Instancja notatnika SageMaker. Są one dostarczane z preinstalowanym Dockerem i używamy go do tworzenia warstw Lambda. Aby skonfigurować instancję notatek, wykonaj następujące czynności:
  • W konsoli SageMaker utwórz instancję notatnika i podaj nazwę notatnika, typ instancji (w tym poście używamy ml.c5.large), rolę uprawnień i inne parametry.
  • Sklonuj repozytorium publiczne i dodaj Repozytorium YOLOv5 dostarczone przez Ultralytics.

Hostuj YOLOv5 na punkcie końcowym SageMaker

Zanim będziemy mogli hostować wstępnie wytrenowany model YOLOv5 w SageMaker, musimy go wyeksportować i spakować w odpowiedniej strukturze katalogów wewnątrz model.tar.gz. W tym poście pokazujemy, jak hostować YOLOv5 w saved_model format. Repozytorium YOLOv5 zapewnia export.py plik, który może eksportować model na wiele różnych sposobów. Po sklonowaniu YOLOv5 i wejściu do katalogu YOLOv5 z wiersza poleceń, możesz wyeksportować model za pomocą następującego polecenia:

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

To polecenie tworzy nowy katalog o nazwie yolov5l_saved_model wewnątrz yolov5 informator. W środku yolov5l_saved_model katalogu, powinniśmy zobaczyć następujące pozycje:

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

Aby utworzyć model.tar.gz plik, przenieś zawartość yolov5l_saved_model do export/Servo/1. Z wiersza poleceń możemy skompresować export katalogu, uruchamiając następujące polecenie i przesyłając model do zasobnika 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>"

Następnie możemy wdrożyć punkt końcowy SageMaker z notatnika SageMaker, uruchamiając następujący kod:

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)

Powyższy skrypt zajmuje około 2-3 minut, aby w pełni wdrożyć model w punkcie końcowym SageMaker. Możesz monitorować stan wdrożenia w konsoli SageMaker. Po pomyślnym hostowaniu modelu model jest gotowy do wnioskowania.

Przetestuj punkt końcowy SageMaker

Po pomyślnym umieszczeniu modelu w punkcie końcowym SageMaker możemy go przetestować, co robimy przy użyciu pustego obrazu. Kod testowy wygląda następująco:

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)

Skonfiguruj Lambdę z warstwami i wyzwalaczami

Używamy OpenCV do zademonstrowania modelu poprzez przekazanie obrazu i uzyskanie wyników wnioskowania. Lambda nie jest dostarczana z zewnętrznymi bibliotekami, takimi jak prekompilowane OpenCV, dlatego musimy je zbudować, zanim będziemy mogli wywołać kod Lambda. Ponadto chcemy mieć pewność, że nie budujemy zewnętrznych bibliotek, takich jak OpenCV, za każdym razem, gdy wywoływana jest Lambda. W tym celu Lambda udostępnia funkcjonalność tworzenia warstw Lambda. Możemy zdefiniować, co dzieje się w tych warstwach i mogą one być wykorzystywane przez kod Lambda za każdym razem, gdy jest on wywoływany. Pokazujemy również, jak tworzyć warstwy Lambda dla OpenCV. W tym poście używamy an Elastyczna chmura obliczeniowa Amazon (Amazon EC2) wystąpienie do tworzenia warstw.

Po umieszczeniu warstw tworzymy app.py skrypt, który jest kodem Lambda, który używa warstw, uruchamia wnioskowanie i uzyskuje wyniki. Poniższy diagram ilustruje ten przepływ pracy.

Twórz warstwy Lambda dla OpenCV za pomocą Docker

Użyj Dockerfile w następujący sposób, aby utworzyć obraz Docker za pomocą Pythona 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/

Zbuduj i uruchom Dockera i przechowuj wyjściowy plik ZIP w bieżącym katalogu pod 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

Teraz możemy przesłać artefakty warstwy OpenCV do Amazon S3 i utworzyć warstwę 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

Po pomyślnym wykonaniu powyższych poleceń, masz warstwę OpenCV w Lambdzie, którą możesz przejrzeć w konsoli Lambda.

Utwórz funkcję Lambda

Korzystamy z app.py skrypt do tworzenia funkcji Lambda i korzystania z OpenCV. W poniższym kodzie zmień wartości dla BUCKET_NAME i IMAGE_LOCATION do lokalizacji dostępu do obrazu:

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

Wdróż funkcję Lambda z następującym kodem:

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

Dołącz warstwę OpenCV do funkcji Lambda

Po utworzeniu funkcji Lambda i warstwy możemy połączyć warstwę z funkcją w następujący sposób:

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

Ustawienia warstw możemy przejrzeć za pomocą konsoli Lambda.

Wyzwalaj Lambdę, gdy obraz jest przesyłany do Amazon S3

Używamy przesłanego obrazu do Amazon S3 jako wyzwalacza do uruchomienia funkcji Lambda. Aby uzyskać instrukcje, zobacz Samouczek: Używanie wyzwalacza Amazon S3 do wywołania funkcji Lambda.

Powinieneś zobaczyć następujące szczegóły funkcji w konsoli Lambda.

Uruchom wnioskowanie

Po skonfigurowaniu Lambda i punktu końcowego SageMaker możesz przetestować dane wyjściowe, wywołując funkcję Lambda. Używamy obrazu przesłanego do Amazon S3 jako wyzwalacza do wywołania Lambda, który z kolei wywołuje punkt końcowy do wnioskowania. Jako przykład przesyłamy następujący obraz do lokalizacji Amazon S3 <S3 PATH TO IMAGE>/test_image.png skonfigurowane w poprzedniej sekcji.

Po przesłaniu obrazu funkcja Lambda jest uruchamiana w celu pobrania i odczytania danych obrazu oraz wysłania ich do punktu końcowego SageMaker w celu wnioskowania. Wynik wyjściowy z punktu końcowego SageMaker jest uzyskiwany i zwracany przez funkcję w formacie JSON, z którego możemy korzystać na różne sposoby. Poniższy obraz przedstawia przykładowe dane wyjściowe nałożone na obraz.

Sprzątać

W zależności od typu wystąpienia notatniki SageMaker mogą wymagać znacznego wykorzystania mocy obliczeniowej i kosztów. Aby uniknąć niepotrzebnych kosztów, radzimy zatrzymywać instancję notebooka, gdy nie jest używana. Ponadto funkcje Lambda i punkty końcowe SageMaker ponoszą opłaty tylko wtedy, gdy są wywoływane. Dlatego te usługi nie wymagają czyszczenia. Jeśli jednak punkt końcowy nie jest już używany, dobrym rozwiązaniem jest usunięcie punktu końcowego i modelu.

Wnioski

W tym poście pokazaliśmy, jak hostować wstępnie wytrenowany model YOLOv5 na punkcie końcowym SageMaker i używać Lambda do wywoływania wnioskowania i przetwarzania danych wyjściowych. Szczegółowy kod jest dostępny na GitHub.

Aby dowiedzieć się więcej o punktach końcowych SageMaker, sprawdź Stwórz swój punkt końcowy i wdróż swój model i Twórz, testuj i wdrażaj swoje modele wnioskowania Amazon SageMaker w AWS Lambda, który pokazuje, w jaki sposób można zautomatyzować proces wdrażania modeli YOLOv5.

O autorach

Kevin piosenki jest analitykiem danych IoT Edge w AWS Professional Services. Kevin posiada doktorat z biofizyki na Uniwersytecie w Chicago. Posiada ponad 4-letnie doświadczenie branżowe w zakresie widzenia komputerowego i uczenia maszynowego. Zajmuje się pomaganiem klientom z branży sportowej i life sciences we wdrażaniu modeli uczenia maszynowego.

Romil Szach jest analitykiem danych IoT Edge w AWS Professional Services. Romil ma ponad 6-letnie doświadczenie w branży w zakresie komputerowych urządzeń wizyjnych, uczenia maszynowego i urządzeń brzegowych IoT. Zajmuje się pomaganiem klientom w optymalizacji i wdrażaniu ich modeli uczenia maszynowego dla urządzeń brzegowych do instalacji przemysłowych.