Maksimalkan kinerja Difusi Stabil dan hemat biaya inferensi dengan AWS Inferentia2 | Layanan Web Amazon

Model AI generatif telah mengalami pertumbuhan pesat dalam beberapa bulan terakhir karena kemampuannya yang mengesankan dalam membuat teks, gambar, kode, dan audio yang realistis. Di antara model-model ini, model Difusi Stabil menonjol karena kekuatan uniknya dalam menciptakan gambar berkualitas tinggi berdasarkan perintah teks. Difusi Stabil dapat menghasilkan berbagai macam gambar berkualitas tinggi, termasuk potret realistis, lanskap, dan bahkan seni abstrak. Dan, seperti model AI generatif lainnya, model Difusi Stabil memerlukan komputasi yang kuat untuk memberikan inferensi berlatensi rendah.

Dalam postingan ini, kami menunjukkan bagaimana Anda dapat menjalankan model Difusi Stabil dan mencapai kinerja tinggi dengan biaya terendah Cloud komputasi elastis Amazon (Amazon EC2) menggunakan Contoh Amazon EC2 Inf2 didukung oleh AWS Inferensia2. Kami melihat arsitektur model Difusi Stabil dan menelusuri langkah-langkah menyusun model Difusi Stabil menggunakan Neuron AWS dan menyebarkannya ke instans Inf2. Kami juga membahas pengoptimalan yang dilakukan Neuron SDK secara otomatis untuk meningkatkan kinerja. Anda dapat menjalankan versi Stable Diffusion 2.1 dan 1.5 di AWS Inferentia2 dengan hemat biaya. Terakhir, kami menunjukkan bagaimana Anda dapat menerapkan model Difusi Stabil ke instans Inf2 dengan Amazon SageMaker.

Ukuran model Stable Diffusion 2.1 di floating point 32 (FP32) adalah 5 GB dan 2.5 GB di bfoat16 (BF16). Satu instans inf2.xlarge memiliki satu akselerator AWS Inferentia2 dengan memori HBM 32 GB. Model Stable Diffusion 2.1 dapat ditampung pada satu instans inf2.xlarge. Difusi Stabil adalah model teks-ke-gambar yang dapat Anda gunakan untuk membuat gambar dengan gaya dan konten berbeda hanya dengan memberikan perintah teks sebagai masukan. Untuk mempelajari lebih lanjut tentang arsitektur model Difusi Stabil, lihat Buat gambar berkualitas tinggi dengan model Difusi Stabil dan terapkan secara hemat biaya dengan Amazon SageMaker.

Bagaimana Neuron SDK mengoptimalkan kinerja Difusi Stabil

Sebelum kita dapat menerapkan model Stable Diffusion 2.1 pada instans AWS Inferentia2, kita perlu mengkompilasi komponen model menggunakan SDK Neuron. Neuron SDK, yang mencakup kompiler pembelajaran mendalam, runtime, dan alat, mengkompilasi dan secara otomatis mengoptimalkan model pembelajaran mendalam sehingga model tersebut dapat berjalan secara efisien pada instans Inf2 dan mengekstrak kinerja penuh dari akselerator AWS Inferentia2. Kami memiliki contoh yang tersedia untuk model Difusi Stabil 2.1 di GitHub repo. Buku catatan ini menyajikan contoh menyeluruh tentang cara mengkompilasi model Difusi Stabil, menyimpan model Neuron yang dikompilasi, dan memuatnya ke dalam runtime untuk inferensi.

Kami menggunakan StableDiffusionPipeline dari Wajah Memeluk diffusers perpustakaan untuk memuat dan mengkompilasi model. Kami kemudian mengkompilasi semua komponen model untuk Neuron menggunakan torch_neuronx.trace() dan simpan model yang dioptimalkan sebagai TorchScript. Proses kompilasi bisa memakan banyak memori dan memerlukan sejumlah besar RAM. Untuk menghindari hal ini, sebelum menelusuri setiap model, kami membuat a deepcopy dari bagian pipa yang sedang ditelusuri. Setelah ini, kami menghapus objek pipa dari memori menggunakan del pipe. Teknik ini sangat berguna ketika mengkompilasi instance dengan RAM rendah.

Selain itu, kami juga melakukan optimasi pada model Difusi Stabil. UNet memegang aspek inferensi yang paling intensif secara komputasi. Komponen UNet beroperasi pada tensor masukan yang memiliki ukuran batch dua, menghasilkan tensor keluaran yang sesuai juga dengan ukuran batch dua, untuk menghasilkan satu gambar. Unsur-unsur dalam kumpulan ini sepenuhnya independen satu sama lain. Kita dapat memanfaatkan perilaku ini untuk mendapatkan latensi optimal dengan menjalankan satu batch pada setiap inti Neuron. Kami mengkompilasi UNet untuk satu batch (dengan menggunakan input tensor dengan satu batch), lalu menggunakan torch_neuronx.DataParallel API untuk memuat model batch tunggal ini ke setiap inti. Output dari API ini adalah modul dua batch yang mulus: kita dapat meneruskan input dari dua batch ke UNet, dan output dua batch dikembalikan, tetapi secara internal, dua model batch tunggal berjalan pada dua inti Neuron. . Strategi ini mengoptimalkan pemanfaatan sumber daya dan mengurangi latensi.

Kompilasi dan terapkan model Difusi Stabil pada instans Inf2 EC2

Untuk mengkompilasi dan menerapkan model Difusi Stabil pada instans Inf2 EC2, masuk ke Konsol Manajemen AWS dan buat instance inf2.8xlarge. Perhatikan bahwa instance inf2.8xlarge hanya diperlukan untuk kompilasi model karena kompilasi memerlukan memori host yang lebih tinggi. Model Difusi Stabil dapat dihosting pada instans inf2.xlarge. Anda dapat menemukan AMI terbaru dengan perpustakaan Neuron menggunakan yang berikut ini Antarmuka Baris Perintah AWS Perintah (AWS CLI):

aws ec2 describe-images --region us-east-1 --owners amazon --filters 'Name=name,Values=Deep Learning AMI Neuron PyTorch 1.13.? (Amazon Linux 2) ????????' 'Name=state,Values=available' --query 'reverse(sort_by(Images, &CreationDate))[:1].ImageId' --output text

Untuk contoh ini, kami membuat instans EC2 menggunakan Deep Learning AMI Neuron PyTorch 1.13 (Ubuntu 20.04). Anda kemudian dapat membuat lingkungan lab JupyterLab dengan menghubungkan ke instans dan menjalankan langkah-langkah berikut:

run source /opt/aws_neuron_venv_pytorch/bin/activate
pip install jupyterlab
jupyter-lab

Buku catatan dengan semua langkah untuk mengompilasi dan menghosting model ada di dalamnya GitHub.

Mari kita lihat langkah-langkah kompilasi untuk salah satu blok encoder teks. Blok lain yang merupakan bagian dari pipa Difusi Stabil dapat dikompilasi dengan cara yang sama.

Langkah pertama adalah memuat model terlatih dari Hugging Face. Itu StableDiffusionPipeline.from_pretrained metode memuat model yang telah dilatih sebelumnya ke dalam objek saluran pipa kita, pipe. Kami kemudian membuat a deepcopy encoder teks dari saluran kami, yang secara efektif mengkloningnya. Itu del pipe perintah kemudian digunakan untuk menghapus objek pipa asli, mengosongkan memori yang digunakan olehnya. Di sini, kami mengkuantisasi model ke bobot BF16:

model_id = "stabilityai/stable-diffusion-2-1-base"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
text_encoder = copy.deepcopy(pipe.text_encoder)
del pipe

Langkah ini melibatkan membungkus pembuat enkode teks kita dengan NeuronTextEncoder pembungkus. Output dari modul encoder teks yang dikompilasi akan berupa dict. Kita ubah menjadi a list ketik menggunakan pembungkus ini:

text_encoder = NeuronTextEncoder(text_encoder)

Kami menginisialisasi tensor PyTorch emb dengan beberapa nilai. Itu emb tensor digunakan sebagai contoh masukan untuk torch_neuronx.trace fungsi. Fungsi ini menelusuri encoder teks kita dan mengkompilasinya ke dalam format yang dioptimalkan untuk Neuron. Jalur direktori untuk model yang dikompilasi dibuat dengan menggabungkan COMPILER_WORKDIR_ROOT dengan subdirektori text_encoder:

emb = torch.tensor([...])
text_encoder_neuron = torch_neuronx.trace(
        text_encoder.neuron_text_encoder,
        emb,
        compiler_workdir=os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder'),
        )

Encoder teks yang dikompilasi disimpan menggunakan torch.jit.save. Itu disimpan dengan nama file model.pt di text_encoder direktori ruang kerja kompiler kami:

text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder/model.pt')
torch.jit.save(text_encoder_neuron, text_encoder_filename)

Grafik buku catatan mencakup langkah serupa untuk mengkompilasi komponen model lainnya: UNet, decoder VAE, dan VAE post_quant_conv. Setelah Anda mengompilasi semua model, Anda dapat memuat dan menjalankan model dengan mengikuti langkah-langkah berikut:

1. Tentukan jalur untuk model yang dikompilasi.
2. Muat yang sudah terlatih StableDiffusionPipeline model, dengan konfigurasinya ditentukan untuk menggunakan tipe data bfloat16.
3. Muat model UNet ke dua inti Neuron menggunakan torch_neuronx.DataParallel API. Hal ini memungkinkan dilakukannya inferensi paralel data, yang dapat mempercepat performa model secara signifikan.
4. Muat bagian model yang tersisa (text_encoder, decoder, dan post_quant_conv) ke satu inti Neuron.

Anda kemudian dapat menjalankan alur dengan memberikan teks masukan sebagai perintah. Berikut ini adalah beberapa gambar yang dihasilkan oleh model untuk petunjuknya:

• Potret renaud sechan, pena dan tinta, gambar garis rumit, oleh craig mullins, ruan jia, kentaro miura, greg rutkowski, loundraw

• Potret penambang batu bara tua abad ke-19, lukisan indah, dengan lukisan wajah yang sangat detail karya greg rutkowski

• Sebuah kastil di tengah hutan

Host Difusi Stabil 2.1 di AWS Inferentia2 dan SageMaker

Menghosting model Difusi Stabil dengan SageMaker juga memerlukan kompilasi dengan Neuron SDK. Anda dapat menyelesaikan kompilasi sebelumnya atau selama runtime menggunakan kontainer Large Model Inference (LMI). Kompilasi sebelumnya memungkinkan waktu pemuatan model lebih cepat dan merupakan opsi yang lebih disukai.

Kontainer LMI SageMaker menyediakan dua cara untuk menerapkan model:

• Opsi tanpa kode dimana kami hanya menyediakan a serving.properties file dengan konfigurasi yang diperlukan
• Bawalah skrip inferensi Anda sendiri

Kami melihat kedua solusi dan membahas konfigurasi dan skrip inferensi (model.py). Dalam postingan ini, kami mendemonstrasikan penerapan menggunakan model yang telah dikompilasi sebelumnya dan disimpan dalam file Layanan Penyimpanan Sederhana Amazon (Amazon S3) ember. Anda dapat menggunakan model yang telah dikompilasi sebelumnya ini untuk penerapan Anda.

Konfigurasikan model dengan skrip yang disediakan

Di bagian ini, kami menunjukkan cara mengonfigurasi kontainer LMI untuk menghosting model Difusi Stabil. Notebook SD2.1 tersedia di GitHub. Langkah pertama adalah membuat paket konfigurasi model sesuai struktur direktori berikut. Tujuan kami adalah menggunakan konfigurasi model minimal yang diperlukan untuk menghosting model tersebut. Struktur direktori yang dibutuhkan adalah sebagai berikut:

<config-root-directory> / 
    ├── serving.properties
    │   
    └── model.py [OPTIONAL]

Selanjutnya, kami membuat file melayani.properti file dengan parameter berikut:

%%writefile code_sd/serving.properties
engine=Python
option.entryPoint=djl_python.transformers-neuronx
option.use_stable_diffusion=True
option.model_id=s3url
option.tensor_parallel_degree=2
option.dtype=bf16

Parameternya menentukan hal berikut:

• pilihan.model_id – Kontainer LMI menggunakan s5cmd untuk memuat model dari lokasi S3 dan oleh karena itu kita perlu menentukan lokasi di mana bobot kompilasi kita berada.
• opsi.entryPoint – Untuk menggunakan penangan bawaan, kami menentukan kelas transformator-neuronx. Jika Anda memiliki skrip inferensi khusus, Anda harus menyediakannya.
• pilihan.dtype – Ini menentukan untuk memuat beban dalam ukuran tertentu. Untuk posting ini, kami menggunakan BF16, yang selanjutnya mengurangi kebutuhan memori kami vs. FP32 dan karenanya menurunkan latensi kami.
• opsi.tensor_parallel_degree – Parameter ini menentukan jumlah akselerator yang kami gunakan untuk model ini. Akselerator chip AWS Inferentia2 memiliki dua inti Neuron sehingga menentukan nilai 2 berarti kita menggunakan satu akselerator (dua inti). Ini berarti kita sekarang dapat membuat banyak pekerja untuk meningkatkan throughput titik akhir.
• pilihan.mesin – Ini disetel ke Python untuk menunjukkan bahwa kami tidak akan menggunakan kompiler lain seperti DeepSpeed ​​atau Faster Transformer untuk hosting ini.

Bawa skrip Anda sendiri

Jika Anda ingin membawa skrip inferensi khusus Anda sendiri, Anda harus menghapusnya option.entryPoint dari serving.properties. Wadah LMI dalam hal ini akan mencari a model.py file di lokasi yang sama dengan serving.properties dan menggunakannya untuk menjalankan inferensi.

Buat skrip inferensi Anda sendiri (model.py)

Membuat skrip inferensi Anda sendiri relatif mudah menggunakan wadah LMI. Wadah membutuhkan Anda model.py file untuk memiliki implementasi metode berikut:

def handle(inputs: Input) which returns an object of type Outputs

Mari kita periksa beberapa bidang penting dari buku catatan terlampir, yang mendemonstrasikan fungsi bawa skrip Anda sendiri.

Ganti cross_attention modul dengan versi yang dioptimalkan:

# Replace original cross-attention module with custom cross-attention module for better performance
    CrossAttention.get_attention_scores = get_attention_scores
Load the compiled weights for the following
text_encoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'text_encoder.pt')
decoder_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'vae_decoder.pt')
unet_filename = os.path.join(COMPILER_WORKDIR_ROOT, 'unet.pt')
post_quant_conv_filename =. os.path.join(COMPILER_WORKDIR_ROOT, 'vae_post_quant_conv.pt')

Ini adalah nama file bobot terkompilasi yang kami gunakan saat membuat kompilasi. Jangan ragu untuk mengubah nama file, tetapi pastikan nama file bobot Anda sesuai dengan yang Anda tentukan di sini.

Kemudian kita perlu memuatnya menggunakan Neuron SDK dan mengaturnya dalam bobot model sebenarnya. Saat memuat bobot yang dioptimalkan UNet, perhatikan bahwa kami juga menentukan jumlah inti Neuron yang kami perlukan untuk memuatnya. Di sini, kita memuat ke satu akselerator dengan dua inti:

# Load the compiled UNet onto two neuron cores.
    pipe.unet = NeuronUNet(UNetWrap(pipe.unet))
    logging.info(f"Loading model: unet:created")
    device_ids = [idx for idx in range(tensor_parallel_degree)]
   
    pipe.unet.unetwrap = torch_neuronx.DataParallel(torch.jit.load(unet_filename), device_ids, set_dynamic_batching=False)
   
 
    # Load other compiled models onto a single neuron core.
 
    # - load encoders
    pipe.text_encoder = NeuronTextEncoder(pipe.text_encoder)
    clip_compiled = torch.jit.load(text_encoder_filename)
    pipe.text_encoder.neuron_text_encoder = clip_compiled
    #- load decoders
    pipe.vae.decoder = torch.jit.load(decoder_filename)
    pipe.vae.post_quant_conv = torch.jit.load(post_quant_conv_filename)

Menjalankan inferensi dengan prompt akan memanggil objek pipa untuk menghasilkan gambar.

Buat titik akhir SageMaker

Kami menggunakan API Boto3 untuk membuat titik akhir SageMaker. Selesaikan langkah-langkah berikut:

1. Buat tarball hanya dengan penyajian dan opsional model.py file dan unggah ke Amazon S3.
2. Buat model menggunakan wadah gambar dan tarball model yang diunggah sebelumnya.
3. Buat konfigurasi titik akhir menggunakan parameter utama berikut:
   1. Gunakan sebuah ml.inf2.xlarge contoh.
   2. set ContainerStartupHealthCheckTimeoutInSeconds hingga 240 untuk memastikan pemeriksaan kesehatan dimulai setelah model diterapkan.
   3. set VolumeInGB ke nilai yang lebih besar sehingga dapat digunakan untuk memuat bobot model yang berukuran 32 GB.

Buat model SageMaker

Setelah Anda membuat file model.tar.gz dan mengunggahnya ke Amazon S3, kita perlu membuat model SageMaker. Kami menggunakan wadah LMI dan artefak model dari langkah sebelumnya untuk membuat model SageMaker. SageMaker memungkinkan kita untuk menyesuaikan dan memasukkan berbagai variabel lingkungan. Untuk alur kerja ini, kita dapat membiarkan semuanya sebagai default. Lihat kode berikut:

inference_image_uri = (
    f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0 djl-serving-inf2"
)

Buat objek model, yang pada dasarnya membuat container lockdown yang dimuat ke instance dan digunakan untuk inferensi:

model_name = name_from_base(f"inf2-sd")
create_model_response = boto3_sm_client.create_model(
    ModelName=model_name,
    ExecutionRoleArn=role,
    PrimaryContainer={"Image": inference_image_uri, "ModelDataUrl": s3_code_artifact},
)

Buat titik akhir SageMaker

Dalam demo ini, kami menggunakan instance ml.inf2.xlarge. Kita perlu mengaturnya VolumeSizeInGB parameter untuk menyediakan ruang disk yang diperlukan untuk memuat model dan bobot. Parameter ini berlaku untuk instans yang mendukung Toko Blok Elastis Amazon Lampiran volume (Amazon EBS). Kita dapat membiarkan waktu tunggu pengunduhan model dan pemeriksaan kesehatan startup kontainer ke nilai yang lebih tinggi, yang akan memberikan waktu yang cukup bagi kontainer untuk menarik bobot dari Amazon S3 dan memuat ke akselerator AWS Inferentia2. Untuk lebih jelasnya, lihat BuatEndpointConfig.

endpoint_config_response = boto3_sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name,
    ProductionVariants=[
        {
            "VariantName": "variant1",
            "ModelName": model_name,
            "InstanceType": "ml.inf2.xlarge", # - 
            "InitialInstanceCount": 1,
            "ContainerStartupHealthCheckTimeoutInSeconds": 360, 
            "VolumeSizeInGB": 400
        },
    ],
)

Terakhir, kami membuat titik akhir SageMaker:

create_endpoint_response = boto3_sm_client.create_endpoint(
    EndpointName=f"{endpoint_name}", EndpointConfigName=endpoint_config_name
)

Panggil titik akhir model

Ini adalah model generatif, jadi kami meneruskan perintah yang digunakan model tersebut untuk menghasilkan gambar. Payloadnya bertipe JSON:

response_model = boto3_sm_run_client.invoke_endpoint( EndpointName=endpoint_name,
    Body=json.dumps(
        {
            "prompt": "Mountain Landscape", 
            "parameters": {} # 
        }
    ), 
    ContentType="application/json",
)

Membandingkan model Difusi Stabil pada Inf2

Kami menjalankan beberapa pengujian untuk membandingkan model Difusi Stabil dengan tipe data BF 16 di Inf2, dan kami dapat memperoleh angka latensi yang menyaingi atau melampaui beberapa akselerator lain untuk Difusi Stabil. Hal ini, ditambah dengan biaya chip AWS Inferentia2 yang lebih rendah, menjadikannya proposisi yang sangat berharga.

Angka-angka berikut berasal dari model Difusi Stabil yang diterapkan pada instans inf2.xl. Untuk informasi lebih lanjut tentang biaya, lihat Instans Amazon EC2 Inf2.

Kesimpulan

Dalam postingan ini, kami mendalami kompilasi, pengoptimalan, dan penerapan model Stable Diffusion 2.1 menggunakan instance Inf2. Kami juga mendemonstrasikan penerapan model Difusi Stabil menggunakan SageMaker. Instans Inf2 juga memberikan performa harga yang luar biasa untuk Difusi Stabil 1.5. Untuk mempelajari lebih lanjut mengapa instans Inf2 cocok untuk AI generatif dan model bahasa besar, lihat Instans Inf2 Amazon EC2 untuk Inferensi AI Generatif Berbiaya Rendah dan Berkinerja Tinggi Kini Tersedia Secara Umum. Untuk detail kinerja, lihat Kinerja Inf2. Lihat contoh tambahan di GitHub repo.

Terima kasih khusus kepada Matthew Mcclain, Beni Hegedus, Kamran Khan, Shruti Koparkar, dan Qing Lan karena telah meninjau dan memberikan masukan yang berharga.

Tentang Penulis

Vivek Gangasani adalah Arsitek Solusi Pembelajaran Mesin Senior di Amazon Web Services. Dia bekerja dengan startup pembelajaran mesin untuk membangun dan menerapkan aplikasi AI/ML di AWS. Saat ini dia fokus memberikan solusi untuk MLOps, inferensi ML, dan ML kode rendah. Dia telah mengerjakan proyek di berbagai domain, termasuk pemrosesan bahasa alami dan visi komputer.

KC Tung adalah Arsitek Solusi Senior di AWS Annapurna Labs. Dia berspesialisasi dalam pelatihan dan penerapan model deep learning berskala besar di cloud. Dia memiliki gelar Ph.D. dalam biofisika molekuler dari University of Texas Southwestern Medical Center di Dallas. Dia telah berbicara di AWS Summits dan AWS Reinvent. Hari ini dia membantu pelanggan melatih dan menerapkan model PyTorch dan TensorFlow besar di AWS cloud. Dia adalah penulis dua buku: Pelajari Perusahaan TensorFlow dan TensorFlow 2 Referensi Saku.

Rupinder Grewal adalah Arsitek Solusi Spesialis Sr Ai/ML dengan AWS. Dia saat ini berfokus pada penyajian model dan MLOps di SageMaker. Sebelum peran ini, ia telah bekerja sebagai Insinyur Pembelajaran Mesin yang membangun dan menjadi model hosting. Di luar pekerjaan ia menikmati bermain tenis dan bersepeda di jalur gunung.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Otomotif / EV, Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• BlockOffset. Modernisasi Kepemilikan Offset Lingkungan. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/maximize-stable-diffusion-performance-and-lower-inference-costs-with-aws-inferentia2/