Skalakan inferensi YOLOv5 dengan titik akhir Amazon SageMaker dan AWS Lambda

Setelah ilmuwan data dengan hati-hati membuat model pembelajaran mesin (ML) yang memuaskan, model tersebut harus diterapkan agar mudah diakses untuk inferensi oleh anggota organisasi lainnya. Namun, menerapkan model dalam skala besar dengan biaya yang dioptimalkan dan efisiensi komputasi dapat menjadi tugas yang menakutkan dan rumit. Amazon SageMaker titik akhir memberikan solusi yang mudah diskalakan dan hemat biaya untuk penerapan model. Model YOLOv5, didistribusikan di bawah lisensi GPLv3, adalah model deteksi objek populer yang dikenal dengan efisiensi runtime serta akurasi deteksi. Dalam posting ini, kami mendemonstrasikan cara meng-host model YOLOv5 yang telah dilatih sebelumnya di titik akhir SageMaker dan menggunakan AWS Lambda berfungsi untuk memanggil titik akhir ini.

Ikhtisar solusi

Gambar berikut menguraikan layanan AWS yang digunakan untuk menghosting model YOLOv5 menggunakan titik akhir SageMaker dan memanggil titik akhir menggunakan Lambda. Notebook SageMaker mengakses model YOLOv5 PyTorch dari Layanan Penyimpanan Sederhana Amazon Bucket (Amazon S3), mengubahnya menjadi YOLOv5 TensorFlow SavedModel format, dan menyimpannya kembali ke bucket S3. Model ini kemudian digunakan saat menghosting titik akhir. Saat gambar diunggah ke Amazon S3, itu bertindak sebagai pemicu untuk menjalankan fungsi Lambda. Fungsi ini menggunakan OpenCV Lapisan lambda untuk membaca gambar yang diunggah dan menjalankan inferensi menggunakan titik akhir. Setelah inferensi dijalankan, Anda dapat menggunakan hasil yang diperoleh darinya sesuai kebutuhan.

Dalam posting ini, kami membahas proses penggunaan model default YOLOv5 di PyTorch dan mengonversinya menjadi TensorFlow SavedModel. Model ini dihosting menggunakan titik akhir SageMaker. Kemudian kami membuat dan menerbitkan fungsi Lambda yang memanggil titik akhir untuk menjalankan inferensi. Model YOLOv5 pra-terlatih tersedia di GitHub. Untuk tujuan posting ini, kami menggunakan yolov5l Model.

Prasyarat

Sebagai prasyarat, kita perlu menyiapkan yang berikut: Identitas AWS dan Manajemen Akses (IAM) peran dengan tepat kebijakan akses untuk SageMaker, Lambda, dan Amazon S3:

• Peran IAM SageMaker – Ini membutuhkan AmazonS3FullAccess kebijakan yang dilampirkan untuk menyimpan dan mengakses model di bucket S3
• Peran Lambda IAM – Peran ini membutuhkan beberapa kebijakan:
  • Untuk mengakses gambar yang disimpan di Amazon S3, kami memerlukan kebijakan IAM berikut:
    • s3:GetObject
    • s3:ListBucket
  • Untuk menjalankan titik akhir SageMaker, kami memerlukan akses ke kebijakan IAM berikut:
    • sagemaker:ListEndpoints
    • sagemaker:DescribeEndpoint
    • sagemaker:InvokeEndpoint
    • sagemaker:InvokeEndpointAsync

Anda juga memerlukan sumber daya dan layanan berikut:

• Grafik Antarmuka Baris Perintah AWS (AWS CLI), yang kami gunakan untuk membuat dan mengonfigurasi Lambda.
• Instance buku catatan SageMaker. Ini datang dengan Docker yang sudah diinstal sebelumnya, dan kami menggunakan ini untuk membuat lapisan Lambda. Untuk menyiapkan instans notebook, selesaikan langkah-langkah berikut:
  • Di konsol SageMaker, buat instance notebook dan berikan nama notebook, jenis instance (untuk posting ini, kami menggunakan ml.c5.large), peran IAM, dan parameter lainnya.
  • Clone file repositori publik dan tambahkan Repositori YOLOv5 disediakan oleh Ultralitik.

Tuan rumah YOLOv5 di titik akhir SageMaker

Sebelum kita dapat meng-host model YOLOv5 yang telah dilatih sebelumnya di SageMaker, kita harus mengekspor dan mengemasnya dalam struktur direktori yang benar di dalamnya model.tar.gz. Untuk postingan ini, kami mendemonstrasikan cara meng-host YOLOv5 di saved_model format. Repo YOLOv5 menyediakan export.py file yang dapat mengekspor model dengan berbagai cara. Setelah Anda mengkloning YOLOv5 dan masuk ke direktori YOLOv5 dari baris perintah, Anda dapat mengekspor model dengan perintah berikut:

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

Perintah ini membuat direktori baru bernama yolov5l_saved_model dalam yolov5 direktori. Di dalam yolov5l_saved_model direktori, kita akan melihat item berikut:

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

Untuk membuat model.tar.gz file, pindahkan konten yolov5l_saved_model untuk export/Servo/1. Dari baris perintah, kita dapat mengompres export direktori dengan menjalankan perintah berikut dan mengunggah model ke bucket 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>"

Kemudian, kita dapat menerapkan titik akhir SageMaker dari notebook SageMaker dengan menjalankan kode berikut:

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)

Skrip sebelumnya membutuhkan waktu sekitar 2-3 menit untuk menerapkan model sepenuhnya ke titik akhir SageMaker. Anda dapat memantau status penerapan di konsol SageMaker. Setelah model berhasil di-host, model siap untuk inferensi.

Uji titik akhir SageMaker

Setelah model berhasil di-host di titik akhir SageMaker, kita dapat mengujinya, yang kita lakukan menggunakan gambar kosong. Kode pengujiannya adalah sebagai berikut:

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)

Siapkan Lambda dengan lapisan dan pemicu

Kami menggunakan OpenCV untuk mendemonstrasikan model dengan melewatkan gambar dan mendapatkan hasil inferensi. Lambda tidak datang dengan perpustakaan eksternal seperti OpenCV yang sudah dibuat sebelumnya, oleh karena itu kita perlu membangunnya sebelum kita dapat memanggil kode Lambda. Selanjutnya, kami ingin memastikan bahwa kami tidak membangun perpustakaan eksternal seperti OpenCV setiap kali Lambda dipanggil. Untuk tujuan ini, Lambda menyediakan fungsionalitas untuk membuat lapisan Lambda. Kita dapat menentukan apa yang terjadi di lapisan ini, dan mereka dapat dikonsumsi oleh kode Lambda setiap kali dipanggil. Kami juga mendemonstrasikan cara membuat layer Lambda untuk OpenCV. Untuk posting ini, kami menggunakan Cloud komputasi elastis Amazon (Amazon EC2) untuk membuat lapisan.

Setelah kami memiliki lapisan di tempat, kami membuat app.py script, yang merupakan kode Lambda yang menggunakan lapisan, menjalankan inferensi, dan mendapatkan hasil. Diagram berikut menggambarkan alur kerja ini.

Buat lapisan Lambda untuk OpenCV menggunakan Docker

Gunakan Dockerfile sebagai berikut untuk membuat gambar Docker menggunakan 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/

Bangun dan jalankan Docker dan simpan file ZIP keluaran di direktori saat ini di bawah 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

Sekarang kita dapat mengunggah artefak lapisan OpenCV ke Amazon S3 dan membuat lapisan 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

Setelah perintah sebelumnya berhasil dijalankan, Anda memiliki lapisan OpenCV di Lambda, yang dapat Anda tinjau di konsol Lambda.

Buat fungsi Lambda

Kami menggunakan app.py skrip untuk membuat fungsi Lambda dan menggunakan OpenCV. Dalam kode berikut, ubah nilai untuk BUCKET_NAME dan IMAGE_LOCATION ke lokasi untuk mengakses gambar:

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

Deploy fungsi Lambda dengan kode berikut:

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

Lampirkan layer OpenCV ke fungsi Lambda

Setelah kita memiliki fungsi dan lapisan Lambda, kita dapat menghubungkan lapisan ke fungsi sebagai berikut:

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

Kami dapat meninjau pengaturan lapisan melalui konsol Lambda.

Memicu Lambda saat gambar diunggah ke Amazon S3

Kami menggunakan unggahan gambar ke Amazon S3 sebagai pemicu untuk menjalankan fungsi Lambda. Untuk petunjuk, lihat Tutorial: Menggunakan pemicu Amazon S3 untuk menjalankan fungsi Lambda.

Anda akan melihat detail fungsi berikut di konsol Lambda.

Jalankan inferensi

Setelah Anda menyiapkan Lambda dan titik akhir SageMaker, Anda dapat menguji output dengan menjalankan fungsi Lambda. Kami menggunakan unggahan gambar ke Amazon S3 sebagai pemicu untuk memanggil Lambda, yang pada gilirannya memanggil titik akhir untuk inferensi. Sebagai contoh, kami mengunggah gambar berikut ke lokasi Amazon S3 <S3 PATH TO IMAGE>/test_image.png dikonfigurasi di bagian sebelumnya.

Setelah gambar diunggah, fungsi Lambda dipicu untuk mengunduh dan membaca data gambar dan mengirimkannya ke titik akhir SageMaker untuk inferensi. Hasil keluaran dari titik akhir SageMaker diperoleh dan dikembalikan oleh fungsi dalam format JSON, yang dapat kita gunakan dengan cara yang berbeda. Gambar berikut menunjukkan contoh output overlay pada gambar.

Membersihkan

Bergantung pada jenis instans, notebook SageMaker dapat memerlukan penggunaan dan biaya komputasi yang signifikan. Untuk menghindari biaya yang tidak perlu, sebaiknya hentikan instans notebook saat tidak digunakan. Selain itu, fungsi Lambda dan titik akhir SageMaker hanya dikenakan biaya saat dipanggil. Oleh karena itu, tidak diperlukan pembersihan untuk layanan tersebut. Namun, jika titik akhir tidak digunakan lagi, sebaiknya hapus titik akhir dan modelnya.

Kesimpulan

Dalam posting ini, kami mendemonstrasikan cara meng-host model YOLOv5 yang telah dilatih sebelumnya pada titik akhir SageMaker dan menggunakan Lambda untuk menjalankan inferensi dan memproses output. Kode rinci tersedia di GitHub.

Untuk mempelajari lebih lanjut tentang titik akhir SageMaker, lihat Buat titik akhir Anda dan terapkan model Anda dan Bangun, uji, dan terapkan model inferensi Amazon SageMaker Anda ke AWS Lambda, yang menyoroti bagaimana Anda dapat mengotomatiskan proses penerapan model YOLOv5.

Tentang penulis

Lagu Kevin adalah Ilmuwan Data IoT Edge di AWS Professional Services. Kevin meraih gelar PhD di bidang Biofisika dari The University of Chicago. Dia memiliki lebih dari 4 tahun pengalaman industri dalam Computer Vision dan Machine Learning. Dia terlibat dalam membantu pelanggan di industri olahraga dan ilmu kehidupan menerapkan model Pembelajaran Mesin.

Romil Syah adalah Ilmuwan Data IoT Edge di AWS Professional Services. Romil memiliki lebih dari 6 tahun pengalaman industri dalam Computer Vision, Machine Learning, dan perangkat edge IoT. Dia terlibat dalam membantu pelanggan mengoptimalkan dan menerapkan model Machine Learning mereka untuk perangkat edge untuk pengaturan industri.