Jalankan beban kerja inferensi pembelajaran mesin pada instans berbasis AWS Graviton dengan Amazon SageMaker

Hari ini, kami meluncurkan Amazon SageMaker inferensi pada Graviton AWS untuk memungkinkan Anda memanfaatkan manfaat harga, kinerja, dan efisiensi yang berasal dari chip Graviton.

Instans berbasis Graviton tersedia untuk inferensi model di SageMaker. Postingan ini membantu Anda memigrasikan dan menerapkan beban kerja inferensi pembelajaran mesin (ML) dari instans berbasis x86 ke Graviton di SageMaker. Kami memberikan panduan langkah demi langkah untuk menerapkan model terlatih SageMaker Anda ke instans berbasis Graviton, membahas praktik terbaik saat bekerja dengan Graviton, mendiskusikan manfaat harga-kinerja, dan mendemonstrasikan cara menerapkan model TensorFlow pada instans SageMaker Graviton.

Gambaran singkat tentang Graviton

AWS Graviton adalah keluarga prosesor yang dirancang oleh AWS yang memberikan kinerja harga terbaik dan lebih hemat energi daripada rekan-rekan x86 mereka. Prosesor AWS Graviton 3 adalah yang terbaru dalam keluarga prosesor Graviton dan dioptimalkan untuk beban kerja ML, termasuk dukungan untuk bfloat16, dan dua kali bandwidth Single Instruction Multiple Data (SIMD). Ketika kedua fitur ini digabungkan, Graviton 3 dapat memberikan kinerja hingga tiga kali lebih baik dibandingkan instans Graviton 2. Graviton 3 juga menggunakan energi hingga 60% lebih sedikit untuk kinerja yang sama dengan yang sebanding Cloud komputasi elastis Amazon (Amazon EC2) instans. Ini adalah fitur hebat jika Anda ingin mengurangi jejak karbon dan mencapai tujuan keberlanjutan Anda.

Ikhtisar solusi

Untuk menerapkan model Anda ke instans Graviton, Anda dapat menggunakan Kontainer Pembelajaran Jauh AWS or bawa wadah sendiri kompatibel dengan arsitektur Arm v8.2.

Migrasi (atau penerapan baru) model Anda dari instans yang diberdayakan x86 ke instans Graviton sederhana karena AWS menyediakan wadah untuk menghosting model dengan PyTorch, TensorFlow, Scikit-learn, dan XGBoost, dan modelnya adalah agnostik arsitektur. Namun demikian, jika Anda ingin membawa pustaka sendiri, Anda juga dapat melakukannya, cukup pastikan wadah Anda dibangun dengan lingkungan yang mendukung arsitektur Arm64. Untuk informasi lebih lanjut, lihat Membangun wadah algoritme Anda sendiri.

Anda harus menyelesaikan tiga langkah untuk menerapkan model Anda:

1. Buat model SageMaker: Ini akan berisi, di antara parameter lainnya, informasi tentang lokasi file model, wadah yang akan digunakan untuk penerapan, dan lokasi skrip inferensi. (Jika Anda memiliki model yang sudah diterapkan dalam instance inferensi berbasis x86, Anda dapat melewati langkah ini.)
2. Buat konfigurasi titik akhir: Ini akan berisi informasi tentang jenis instans yang Anda inginkan untuk titik akhir (misalnya, ml.c7g.xlarge untuk Graviton3), nama model yang Anda buat di langkah 1, dan jumlah instans per titik akhir.
3. Luncurkan titik akhir dengan konfigurasi titik akhir yang dibuat pada langkah 2.

Prasyarat

Sebelum memulai, pertimbangkan prasyarat berikut:

1. Lengkapi persyaratan seperti yang tercantum di Prasyarat.
2. Model Anda harus berupa model berbasis PyTorch, TensorFlow, XGBoost, atau Scikit-learn. Tabel berikut meringkas versi yang saat ini didukung pada tulisan ini. Untuk update terbaru, lihat SageMaker Framework Containers (khusus dukungan SM).
   

   .	Ular sanca	TensorFlow	PyTorch	Scikit-belajar	XGBoost
   Versi didukung	3.8	2.9.1	1.12.1	1.0-1	1.3-1 hingga 1.5-1

3. Skrip inferensi disimpan di Layanan Penyimpanan Sederhana Amazon (Amazon S3).

Di bagian berikut, kami memandu Anda melalui langkah-langkah penerapan.

Buat model SageMaker

Jika Anda memiliki model yang sudah diterapkan dalam instance inferensi berbasis x86, Anda dapat melewati langkah ini. Jika tidak, selesaikan langkah-langkah berikut untuk membuat model SageMaker:

1. Temukan model yang Anda simpan di bucket S3. Salin URI.
   Anda menggunakan model URI nanti di MODEL_S3_LOCATION.
2. Identifikasi versi framework dan versi Python yang digunakan selama pelatihan model.
   Anda perlu memilih wadah dari daftar AWS Deep Learning Containers yang tersedia per kerangka kerja dan versi Python Anda. Untuk informasi lebih lanjut, lihat Memperkenalkan gambar kontainer multi-arsitektur untuk Amazon ECR.
3. Temukan URI skrip Python inferensi di ember S3 (nama file yang umum adalah inference.py).
   URI skrip inferensi diperlukan di INFERENCE_SCRIPT_S3_LOCATION.
4. Dengan variabel-variabel ini, Anda kemudian dapat memanggil API SageMaker dengan perintah berikut:

   client = boto3.client("sagemaker")
   
   client.create_model(
       ModelName="Your model name",
       PrimaryContainer={
           "Image": ,
           "ModelDataUrl": ,
           "Environment": {
           "SAGEMAKER_PROGRAM": "inference.py",
           "SAGEMAKER_SUBMIT_DIRECTORY": ,
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": 
           }
       },
       ExecutionRoleArn= 
   )

Anda juga dapat membuat gambar multi-arsitektur, dan menggunakan gambar yang sama tetapi dengan tag yang berbeda. Anda dapat menunjukkan pada arsitektur mana instance Anda akan di-deploy. Untuk informasi lebih lanjut, lihat Memperkenalkan gambar kontainer multi-arsitektur untuk Amazon ECR.

Buat konfigurasi titik akhir

Setelah Anda membuat model, Anda harus membuat konfigurasi titik akhir dengan menjalankan perintah berikut (perhatikan jenis instance yang kami gunakan):

client.create_endpoint_config(
    EndpointConfigName= ,
    ProductionVariants=[
        {
         "VariantName": "v0",
         "ModelName": "Your model name",
         "InitialInstanceCount": 1,
         "InstanceType": "ml.c7g.xlarge",
        },
    ]
)

Tangkapan layar berikut menampilkan detail konfigurasi titik akhir di konsol SageMaker.

Luncurkan titik akhir

Dengan konfigurasi titik akhir yang dibuat pada langkah sebelumnya, Anda dapat menerapkan titik akhir:

client.create_endpoint(
    EndpointName = "",
    EndpointConfigName = ""
    )

Tunggu hingga titik akhir model Anda diterapkan. Prediksi dapat diminta dengan cara yang sama seperti Anda meminta prediksi untuk titik akhir yang diterapkan dalam instans berbasis x86.

Tangkapan layar berikut menunjukkan titik akhir Anda di konsol SageMaker.

Apa yang didukung

SageMaker menyediakan wadah dalam Graviton yang dioptimalkan kinerjanya untuk kerangka kerja TensorFlow dan PyTorch. Kontainer ini mendukung visi komputer, pemrosesan bahasa alami, rekomendasi, dan kasus penggunaan inferensi berbasis model yang mendalam dan luas. Selain wadah pembelajaran mendalam, SageMaker juga menyediakan wadah untuk kerangka kerja ML klasik seperti XGBoost dan Scikit-learn. Kontainer tersebut kompatibel dengan biner di seluruh instans c6g/m6g dan c7g, sehingga memigrasikan aplikasi inferensi dari satu generasi ke generasi lainnya berjalan lancar.

C6g/m6g mendukung fp16 (float setengah presisi) dan untuk model yang kompatibel memberikan kinerja yang setara atau lebih baik dibandingkan dengan instans c5. C7g secara substansial meningkatkan performa ML dengan menggandakan lebar SIMD dan mendukung bfloat-16 (bf16), yang merupakan platform paling hemat biaya untuk menjalankan model Anda.

Baik c6g/m6g dan c7g memberikan kinerja yang baik untuk ML klasik (misalnya, XGBoost) dibandingkan dengan instans CPU lainnya di SageMaker. Dukungan Bfloat-16 pada c7g memungkinkan penerapan model terlatih bf16 atau model terlatih AMP (Automatic Mixed Precision) yang efisien. Backend Arm Compute Library (ACL) di Graviton menyediakan kernel bfloat-16 yang bahkan dapat mempercepat operator fp32 melalui mode matematika cepat, tanpa kuantisasi model.

Praktik terbaik yang direkomendasikan

Pada instans Graviton, setiap vCPU adalah inti fisik. Tidak ada pertentangan untuk sumber daya CPU umum (tidak seperti SMT), dan penskalaan kinerja beban kerja bersifat linier dengan setiap penambahan vCPU. Oleh karena itu, disarankan untuk menggunakan inferensi batch kapan pun kasus penggunaan memungkinkan. Ini akan memungkinkan penggunaan vCPU secara efisien dengan memproses batch secara paralel pada setiap inti fisik. Jika inferensi batch tidak memungkinkan, ukuran instans optimal untuk muatan tertentu diperlukan untuk memastikan overhead penjadwalan thread OS tidak melebihi daya komputasi yang disertakan dengan vCPU tambahan.

TensorFlow hadir dengan kernel Eigen secara default, dan disarankan untuk beralih ke OneDNN dengan ACL untuk mendapatkan backend inferensi yang paling optimal. Backend OneDNN dan mode matematika cepat bfloat-16 dapat diaktifkan saat meluncurkan layanan kontainer:

docker run -p 8501:8501 --name tfserving_resnet 
--mount type=bind,source=/tmp/resnet,target=/models/resnet 
-e MODEL_NAME=resnet -e TF_ENABLE_ONEDNN_OPTS=1 
-e DNNL_DEFAULT_FPMATH_MODE=BF16 -e -t tfs:mkl_aarch64

Perintah penyajian sebelumnya menghosting model resnet50 standar dengan dua konfigurasi penting:

-e TF_ENABLE_ONEDNN_OPTS=1
-e DNNL_DEFAULT_FPMATH_MODE=BF16

Ini dapat diteruskan ke wadah inferensi dengan cara berikut:

client.create_model(
    ModelName="Your model name",
    PrimaryContainer={
    "Image": ,
    "ModelDataUrl": ,
    "Environment": {
        "SAGEMAKER_PROGRAM": "inference.py",
        "SAGEMAKER_SUBMIT_DIRECTORY": "",
        "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
        "SAGEMAKER_REGION": ,
        "TF_ENABLE_ONEDNN_OPTS": "1",
        "DNNL_DEFAULT_FPMATH_MODE": "BF16"
         }
     },
     ExecutionRoleArn='ARN for AmazonSageMaker-ExecutionRole'
)

Contoh penerapan

Dalam postingan ini, kami menunjukkan cara menerapkan model TensorFlow, yang dilatih di SageMaker, pada instans inferensi SageMaker bertenaga Graviton.

Anda dapat menjalankan contoh kode baik di instans notebook SageMaker, dan Studio Amazon SageMaker notebook, atau notebook Jupyter dalam mode lokal. Anda perlu mengambil peran eksekusi SageMaker jika Anda menggunakan notebook Jupyter dalam mode lokal.

Contoh berikut mempertimbangkan kumpulan data CIFAR-10. Anda dapat mengikuti contoh buku catatan dari contoh SageMaker GitHub repo untuk mereproduksi model yang digunakan dalam posting ini. Kami menggunakan model terlatih dan cifar10_keras_main.py Skrip Python untuk inferensi.

Model disimpan dalam bucket S3: s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz

Grafik cifar10_keras_main.py skrip, yang dapat digunakan untuk inferensi, disimpan di:s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/script/cifar10_keras_main.py

Kami menggunakan us-east-1 Wilayahkan dan terapkan model pada instans berbasis Graviton ml.c7g.xlarge. Berdasarkan hal ini, URI dari AWS Deep Learning Container kami adalah 763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker

1. Siapkan dengan kode berikut:

   import sagemaker
   import boto3
   import datetime
   import json
   import gzip
   import os
   
   sagemaker_session = sagemaker.Session()
   bucket = sagemaker_session.default_bucket()
   role = sagemaker.get_execution_role()
   region = sagemaker_session.boto_region_name

2. Unduh kumpulan data untuk pengujian titik akhir:

   from keras.datasets import cifar10
   (x_train, y_train), (x_test, y_test) = cifar10.load_data()

3. Buat konfigurasi model dan titik akhir, dan terapkan titik akhir:

   timestamp = "{:%Y-%m-%d-%H-%M-%S}".format(datetime.datetime.now())
   
   client = boto3.client("sagemaker")
   
   MODEL_NAME = f"graviton-model-{timestamp}"
   ENDPOINT_NAME = f"graviton-endpoint-{timestamp}"
   ENDPOINT_CONFIG_NAME = f"graviton-endpoint-config-{timestamp}"
   
   # create sagemaker model
   create_model_response = client.create_model(
       ModelName=MODEL_NAME,
       PrimaryContainer={
       "Image":  "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-graviton:2.9.1-cpu-py38-ubuntu20.04-sagemaker ",
       "ModelDataUrl":  "s3://aws-ml-blog/artifacts/run-ml-inference-on-graviton-based-instances-with-amazon-sagemaker/model.tar.gz",
       "Environment": {
           "SAGEMAKER_CONTAINER_LOG_LEVEL": "20",
           "SAGEMAKER_REGION": region
           }
       },
       ExecutionRoleArn=role
   )
   print ("create_model API response", create_model_response)

4. Secara opsional, Anda dapat menambahkan skrip inferensi ke Environment in create_model jika Anda awalnya tidak menambahkannya sebagai artefak ke model SageMaker Anda selama pelatihan:

   "SAGEMAKER_PROGRAM": "inference.py",
   "SAGEMAKER_SUBMIT_DIRECTORY": ,
   		
   # create sagemaker endpoint config
   create_endpoint_config_response = client.create_endpoint_config(
       EndpointConfigName=ENDPOINT_CONFIG_NAME,
       ProductionVariants=[
           {
            "VariantName": "v0",
            "ModelName": MODEL_NAME,
            "InitialInstanceCount": 1,
            "InstanceType": "ml.c7g.xlarge" 
           },
       ]
   )
   print ("ncreate_endpoint_config API response", create_endpoint_config_response)
   
   # create sagemaker endpoint
   create_endpoint_response = client.create_endpoint(
       EndpointName = ENDPOINT_NAME,
       EndpointConfigName = ENDPOINT_CONFIG_NAME,
   )
   print ("ncreate_endpoint API response", create_endpoint_response)   
   

   Anda harus menunggu beberapa menit agar penerapan dilakukan.

5. Verifikasi status titik akhir dengan kode berikut:

   describe_response = client.describe_endpoint(EndpointName=ENDPOINT_NAME)
   print(describe_response["EndpointStatus"]

   Anda juga dapat memeriksa Konsol Manajemen AWS untuk melihat kapan model Anda di-deploy.

6. Siapkan lingkungan waktu proses untuk memanggil titik akhir:

   runtime = boto3.Session().client(service_name="runtime.sagemaker")

   Sekarang kami menyiapkan payload untuk memanggil titik akhir. Kami menggunakan jenis gambar yang sama dengan yang digunakan untuk pelatihan model. Ini diunduh pada langkah sebelumnya.

7. Transmisikan payload ke tensor dan atur format yang benar yang diharapkan model. Untuk contoh ini, kami hanya meminta satu prediksi.

   input_image = x_test[0].reshape(1,32,32,3)

   Kami mendapatkan output model sebagai array.

8. Kita dapat mengubah keluaran ini menjadi probabilitas jika kita menerapkan softmax padanya:

   CONTENT_TYPE = 'application/json'
   ACCEPT = 'application/json'
   PAYLOAD = json.dumps(input_image.tolist())
   
   response = runtime.invoke_endpoint(
       EndpointName=ENDPOINT_NAME, 
       ContentType=CONTENT_TYPE,
       Accept=ACCEPT,
       Body=PAYLOAD
   )
       
   print(response['Body'].read().decode())

Bersihkan sumber daya

Layanan yang terlibat dalam solusi ini dikenakan biaya. Setelah selesai menggunakan solusi ini, bersihkan sumber daya berikut:

client.delete_endpoint(EndpointName=ENDPOINT_NAME)
client.delete_endpoint_config(EndpointConfigName=ENDPOINT_CONFIG_NAME)
client.delete_model(ModelName=MODEL_NAME)

Perbandingan harga-kinerja

Instans berbasis Graviton menawarkan harga terendah dan kinerja harga terbaik jika dibandingkan dengan instans berbasis x86. Serupa dengan instans EC2, titik akhir inferensi SageMaker dengan instans ml.c6g (Graviton 2) menawarkan harga 20% lebih rendah dibandingkan dengan ml.c5, dan instans Graviton 3 ml.c7g 15% lebih murah daripada instans ml.c6. Untuk informasi lebih lanjut, lihat Harga Amazon SageMaker.

Kesimpulan

Dalam postingan ini, kami memamerkan kemampuan SageMaker yang baru diluncurkan untuk menerapkan model dalam instans inferensi bertenaga Graviton. Kami memberi Anda panduan tentang praktik terbaik dan membahas secara singkat manfaat harga-performa dari jenis instans inferensi yang baru.

Untuk mempelajari lebih lanjut tentang Graviton, lihat Prosesor AWS Graviton. Anda dapat memulai instans EC2 berbasis AWS Graviton di konsol Amazon EC2 dan dengan merujuk ke Panduan Teknis AWS Graviton. Anda dapat menerapkan titik akhir model Sagemaker untuk inferensi di Graviton dengan kode contoh di postingan blog ini.

Tentang penulis

Victor Jaramillo, PhD, adalah Senior Machine Learning Engineer di AWS Professional Services. Sebelum di AWS, dia adalah profesor universitas dan ilmuwan penelitian dalam pemeliharaan prediktif. Di waktu luangnya, ia menikmati mengendarai sepeda motornya dan mekanik sepeda motor DIY.

Zmnako Awrahman, PhD, adalah Manajer Praktik, ML SME, dan anggota Komunitas Lapangan Teknis Pembelajaran Mesin (TFC) di Amazon Web Services. Dia membantu pelanggan memanfaatkan kekuatan cloud untuk mengekstrak nilai dari data mereka dengan analisis data dan pembelajaran mesin.

Sunita Nadampalli adalah Manajer Pengembangan Perangkat Lunak di AWS. Dia memimpin pengoptimalan kinerja perangkat lunak Graviton untuk beban kerja machine leaning, HPC, dan multimedia. Dia bersemangat tentang pengembangan sumber terbuka dan memberikan solusi perangkat lunak yang hemat biaya dengan Arm SoCs.

John Liu adalah Insinyur Pengembangan Perangkat Lunak di tim Amazon SageMaker. Pekerjaannya saat ini berfokus untuk membantu pengembang menghosting model pembelajaran mesin secara efisien dan meningkatkan kinerja inferensi. Dia sangat tertarik dengan analisis data spasial dan menggunakan AI untuk memecahkan masalah sosial.

Alan Tan adalah Manajer Produk Senior dengan SageMaker, memimpin upaya pada inferensi model besar. Dia bersemangat menerapkan pembelajaran mesin ke bidang analitik. Di luar pekerjaan, dia menikmati alam bebas.