Bangun avatar yang dipersonalisasi dengan AI generatif menggunakan Amazon SageMaker | Layanan Web Amazon

AI Generatif telah menjadi alat umum untuk meningkatkan dan mempercepat proses kreatif di berbagai industri, termasuk hiburan, periklanan, dan desain grafis. Hal ini memungkinkan pengalaman yang lebih dipersonalisasi untuk audiens dan meningkatkan kualitas produk akhir secara keseluruhan.

Salah satu manfaat signifikan AI generatif adalah menciptakan pengalaman unik dan personal bagi pengguna. Misalnya, AI generatif digunakan oleh layanan streaming untuk menghasilkan judul dan visual film yang dipersonalisasi guna meningkatkan keterlibatan pemirsa dan membangun visual untuk judul berdasarkan riwayat tontonan dan preferensi pengguna. Sistem kemudian menghasilkan ribuan variasi karya seni suatu judul dan mengujinya untuk menentukan versi mana yang paling menarik perhatian pengguna. Dalam beberapa kasus, karya seni yang dipersonalisasi untuk serial TV secara signifikan meningkatkan rasio klik-tayang dan rasio penayangan dibandingkan dengan acara tanpa karya seni yang dipersonalisasi.

Dalam postingan ini, kami mendemonstrasikan bagaimana Anda dapat menggunakan model AI generatif seperti Difusi Stabil untuk membangun solusi avatar yang dipersonalisasi Amazon SageMaker dan menghemat biaya inferensi dengan titik akhir multi-model (MME) secara bersamaan. Solusinya menunjukkan bagaimana, dengan mengunggah 10–12 gambar diri Anda, Anda dapat menyempurnakan model yang dipersonalisasi yang kemudian dapat menghasilkan avatar berdasarkan perintah teks apa pun, seperti yang ditunjukkan pada tangkapan layar berikut. Meskipun contoh ini menghasilkan avatar yang dipersonalisasi, Anda dapat menerapkan teknik ini pada generasi seni kreatif mana pun dengan menyempurnakan objek atau gaya tertentu.

Ikhtisar solusi

Diagram arsitektur berikut menguraikan solusi end-to-end untuk generator avatar kami.

Ruang lingkup posting ini dan contohnya Kode GitHub kami memberikan fokus hanya pada pelatihan model dan orkestrasi inferensi (bagian hijau pada diagram sebelumnya). Anda dapat mereferensikan arsitektur solusi lengkap dan membangun berdasarkan contoh yang kami berikan.

Pelatihan model dan inferensi dapat dipecah menjadi empat langkah:

1. Unggah gambar ke Layanan Penyimpanan Sederhana Amazon (Amazon S3). Pada langkah ini, kami meminta Anda untuk memberikan minimal 10 gambar diri Anda yang beresolusi tinggi. Semakin banyak gambar, semakin baik hasilnya, tetapi semakin lama waktu yang dibutuhkan untuk melatihnya.
2. Menyempurnakan model dasar Difusi Stabil 2.1 menggunakan inferensi asinkron SageMaker. Kami menjelaskan alasan penggunaan titik akhir inferensi untuk pelatihan nanti di postingan ini. Proses penyempurnaan dimulai dengan menyiapkan gambar, termasuk pemotongan wajah, variasi latar belakang, dan pengubahan ukuran model. Kemudian kami menggunakan Adaptasi Tingkat Rendah (LoRA), sebuah teknik penyesuaian parameter yang efisien untuk model bahasa besar (LLM), untuk menyempurnakan model tersebut. Terakhir, dalam pascapemrosesan, kami mengemas bobot LoRA yang telah disempurnakan dengan skrip inferensi dan file konfigurasi (tar.gz) dan mengunggahnya ke lokasi bucket S3 untuk MME SageMaker.
3. Host model yang disempurnakan menggunakan MME SageMaker dengan GPU. SageMaker akan secara dinamis memuat dan menyimpan model dalam cache dari lokasi Amazon S3 berdasarkan lalu lintas inferensi ke setiap model.
4. Gunakan model yang telah disesuaikan untuk inferensi. Setelah Layanan Pemberitahuan Sederhana Amazon (Amazon SNS) pemberitahuan yang menunjukkan penyesuaian telah dikirim, Anda dapat segera menggunakan model tersebut dengan menyediakan a target_model parameter saat memanggil MME untuk membuat avatar Anda.

Kami menjelaskan setiap langkah secara lebih rinci di bagian berikut dan menelusuri beberapa cuplikan kode contoh.

Siapkan gambarnya

Untuk mencapai hasil terbaik dari menyempurnakan Difusi Stabil untuk menghasilkan gambar diri Anda, Anda biasanya perlu menyediakan foto diri Anda dalam jumlah besar dan beragam dari berbagai sudut, dengan ekspresi berbeda, dan dalam latar belakang berbeda. Namun, dengan penerapan kami, kini Anda dapat memperoleh hasil berkualitas tinggi hanya dengan 10 gambar masukan. Kami juga telah menambahkan pra-pemrosesan otomatis untuk mengekstrak wajah Anda dari setiap foto. Yang Anda butuhkan hanyalah menangkap esensi penampilan Anda dengan jelas dari berbagai perspektif. Sertakan foto menghadap ke depan, foto profil dari setiap sisi, dan foto dari sudut di antaranya. Anda juga harus menyertakan foto dengan ekspresi wajah berbeda seperti tersenyum, mengerutkan kening, dan ekspresi netral. Memiliki perpaduan ekspresi akan memungkinkan model mereproduksi fitur wajah unik Anda dengan lebih baik. Gambar masukan menentukan kualitas avatar yang dapat Anda hasilkan. Untuk memastikan hal ini dilakukan dengan benar, kami merekomendasikan pengalaman UI front-end yang intuitif untuk memandu pengguna melalui proses pengambilan dan pengunggahan gambar.

Berikut ini contoh gambar selfie dengan sudut berbeda dengan ekspresi wajah berbeda.

Menyempurnakan model Difusi Stabil

Setelah gambar diunggah ke Amazon S3, kita dapat memanggil Inferensi asinkron SageMaker titik akhir untuk memulai proses pelatihan kami. Titik akhir asinkron ditujukan untuk kasus penggunaan inferensi dengan muatan besar (hingga 1 GB) dan waktu pemrosesan yang lama (hingga 1 jam). Ini juga menyediakan mekanisme antrian bawaan untuk mengantri permintaan, dan mekanisme pemberitahuan penyelesaian tugas melalui Amazon SNS, selain fitur asli hosting SageMaker lainnya seperti penskalaan otomatis.

Meskipun penyesuaian bukan merupakan kasus penggunaan inferensi, kami memilih untuk menggunakannya di sini sebagai pengganti tugas pelatihan SageMaker karena mekanisme antrian dan pemberitahuan bawaannya dan penskalaan otomatis terkelola, termasuk kemampuan untuk menurunkan skala ke 0 instans saat layanan tidak digunakan. Hal ini memungkinkan kami dengan mudah menskalakan layanan penyesuaian ke sejumlah besar pengguna secara bersamaan dan menghilangkan kebutuhan untuk mengimplementasikan dan mengelola komponen tambahan. Namun, hal ini memiliki kelemahan yaitu payload 1 GB dan waktu pemrosesan maksimum 1 jam. Dalam pengujian kami, kami menemukan bahwa 20 menit adalah waktu yang cukup untuk mendapatkan hasil yang cukup baik dengan sekitar 10 gambar input pada instance ml.g5.2xlarge. Namun, pelatihan SageMaker akan menjadi pendekatan yang direkomendasikan untuk pekerjaan penyesuaian skala besar.

Untuk menghosting titik akhir asinkron, kita harus menyelesaikan beberapa langkah. Yang pertama adalah mendefinisikan server model kita. Untuk posting ini, kami menggunakan Wadah Inferensi Model Besar (LMI). LMI didukung oleh DJL Serving, yang merupakan solusi penyajian model agnostik bahasa pemrograman berkinerja tinggi. Kami memilih opsi ini karena wadah inferensi terkelola SageMaker sudah memiliki banyak perpustakaan pelatihan yang kami perlukan, seperti Hugging Face Diffuser dan Mempercepat. Hal ini sangat mengurangi jumlah pekerjaan yang diperlukan untuk menyesuaikan kontainer untuk pekerjaan penyesuaian kami.

Cuplikan kode berikut menunjukkan versi container LMI yang kita gunakan dalam contoh kita:

inference_image_uri = ( f"763104351884.dkr.ecr.{region}.amazonaws.com/djl-inference:0.21.0-deepspeed0.8.3-cu117"
)
print(f"Image going to be used is ---- > {inference_image_uri}")

Selain itu, kita perlu memiliki serving.properties file yang mengonfigurasi properti penyajian, termasuk mesin inferensi yang akan digunakan, lokasi artefak model, dan pengelompokan dinamis. Terakhir, kita harus memiliki a model.py file yang memuat model ke dalam mesin inferensi dan menyiapkan input dan output data dari model. Dalam contoh kami, kami menggunakan model.py file untuk menjalankan pekerjaan penyesuaian, yang kami jelaskan secara lebih rinci di bagian selanjutnya. Keduanya serving.properties dan model.py file disediakan di training_service folder.

Langkah berikutnya setelah menentukan server model kita adalah membuat konfigurasi titik akhir yang menentukan bagaimana inferensi asinkron kita akan disajikan. Sebagai contoh, kita hanya menentukan batas pemanggilan serentak maksimum dan lokasi output S3. Dengan ml.g5.2xlarge Misalnya, kami menemukan bahwa kami dapat menyempurnakan hingga dua model secara bersamaan tanpa menemui pengecualian kehabisan memori (OOM), dan oleh karena itu kami menetapkan max_concurrent_invocations_per_instance menjadi 2. Jumlah ini mungkin perlu disesuaikan jika kita menggunakan serangkaian parameter penyetelan yang berbeda atau jenis instans yang lebih kecil. Kami merekomendasikan pengaturan ini ke 1 pada awalnya dan memantau penggunaan memori GPU amazoncloudwatch.

# create async endpoint configuration
async_config = AsyncInferenceConfig( output_path=f"s3://{bucket}/{s3_prefix}/async_inference/output" , # Where our results will be stored max_concurrent_invocations_per_instance=2, notification_config={   "SuccessTopic": "...",   "ErrorTopic": "...", }, #  Notification configuration
)

Terakhir, kami membuat model SageMaker yang mengemas informasi kontainer, file model, dan Identitas AWS dan Manajemen Akses (IAM) peran menjadi satu objek. Model ini diterapkan menggunakan konfigurasi titik akhir yang kami tentukan sebelumnya:

model = Model( image_uri=image_uri, model_data=model_data, role=role, env=env
) model.deploy( initial_instance_count=1, instance_type=instance_type, endpoint_name=endpoint_name, async_inference_config=async_inference_config
) predictor = sagemaker.Predictor( endpoint_name=endpoint_name, sagemaker_session=sagemaker_session
)

Ketika titik akhir sudah siap, kami menggunakan kode contoh berikut untuk memanggil titik akhir asinkron dan memulai proses penyesuaian:

sm_runtime = boto3.client("sagemaker-runtime") input_s3_loc = sess.upload_data("data/jw.tar.gz", bucket, s3_prefix) response = sm_runtime.invoke_endpoint_async( EndpointName=sd_tuning.endpoint_name, InputLocation=input_s3_loc)

Untuk detail lebih lanjut tentang LMI di SageMaker, lihat Terapkan model besar di Amazon SageMaker menggunakan inferensi paralel model DJLServing dan DeepSpeed.

Setelah pemanggilan, titik akhir asinkron mulai mengantri pekerjaan penyesuaian kami. Setiap pekerjaan berjalan melalui langkah-langkah berikut: menyiapkan gambar, melakukan penyempurnaan Dreambooth dan LoRA, dan menyiapkan artefak model. Mari selami lebih dalam proses penyesuaiannya.

Siapkan gambarnya

Seperti yang kami sebutkan sebelumnya, kualitas gambar masukan berdampak langsung pada kualitas model yang disempurnakan. Untuk kasus penggunaan avatar, kami ingin model fokus pada fitur wajah. Daripada mengharuskan pengguna untuk memberikan gambar yang dikurasi secara cermat dengan ukuran dan konten yang tepat, kami menerapkan langkah pra-pemrosesan menggunakan teknik visi komputer untuk meringankan beban ini. Pada langkah preprocessing, pertama-tama kita menggunakan model deteksi wajah untuk mengisolasi wajah terbesar di setiap gambar. Kemudian kami memotong dan memasukkan gambar ke ukuran yang diperlukan yaitu 512 x 512 piksel untuk model kami. Terakhir, kami mengelompokkan wajah dari latar belakang dan menambahkan variasi latar belakang secara acak. Ini membantu menyorot fitur wajah, memungkinkan model kita belajar dari wajah itu sendiri, bukan dari latar belakang. Gambar berikut mengilustrasikan tiga langkah dalam proses ini.

Langkah 1: Deteksi wajah menggunakan computer vision	Langkah 2: Pangkas dan padukan gambar menjadi 512 x 512 piksel	Langkah 3 (Opsional): Segmentasikan dan tambahkan variasi latar belakang

Penyempurnaan Dreambooth dan LoRA

Untuk menyempurnakannya, kami menggabungkan teknik Dreambooth dan LoRA. Dreambooth memungkinkan Anda mempersonalisasi model Difusi Stabil, menyematkan subjek ke dalam domain keluaran model menggunakan pengidentifikasi unik dan memperluas kamus visi bahasa model. Ini menggunakan metode yang disebut pelestarian sebelumnya untuk melestarikan pengetahuan semantik model tentang kelas subjek, dalam hal ini seseorang, dan menggunakan objek lain di kelas tersebut untuk meningkatkan keluaran gambar akhir. Beginilah cara Dreambooth mencapai hasil berkualitas tinggi hanya dengan beberapa gambar input subjek.

Cuplikan kode berikut menunjukkan masukan ke file kami trainer.py kelas untuk solusi avatar kami. Perhatikan kami memilih <<TOK>> sebagai pengidentifikasi unik. Hal ini sengaja dilakukan untuk menghindari pemilihan nama yang mungkin sudah ada dalam kamus model. Jika nama tersebut sudah ada, model harus melupakan dan kemudian mempelajari kembali subjeknya, yang dapat menyebabkan hasil penyesuaian yang buruk. Kelas mata pelajaran diatur ke “a photo of person”, yang memungkinkan pelestarian sebelumnya dengan terlebih dahulu membuat foto orang untuk dimasukkan sebagai masukan tambahan selama proses penyesuaian. Hal ini akan membantu mengurangi overfitting saat model mencoba melestarikan pengetahuan sebelumnya dari seseorang menggunakan metode pelestarian sebelumnya.

status = trn.run(base_model="stabilityai/stable-diffusion-2-1-base", resolution=512, n_steps=1000, concept_prompt="photo of <<TOK>>", # << unique identifier of the subject learning_rate=1e-4, gradient_accumulation=1, fp16=True, use_8bit_adam=True, gradient_checkpointing=True, train_text_encoder=True, with_prior_preservation=True, prior_loss_weight=1.0, class_prompt="a photo of person", # << subject class num_class_images=50, class_data_dir=class_data_dir, lora_r=128, lora_alpha=1, lora_bias="none", lora_dropout=0.05, lora_text_encoder_r=64, lora_text_encoder_alpha=1, lora_text_encoder_bias="none", lora_text_encoder_dropout=0.05
)

Sejumlah opsi penghemat memori telah diaktifkan dalam konfigurasi, termasuk fp16, use_8bit_adam, dan akumulasi gradien. Hal ini mengurangi jejak memori hingga di bawah 12 GB, yang memungkinkan penyesuaian hingga dua model secara bersamaan pada satu perangkat. ml.g5.2xlarge contoh.

LoRA adalah teknik penyesuaian yang efisien untuk LLM yang membekukan sebagian besar bobot dan menyambungkan jaringan adaptor kecil ke lapisan tertentu dari LLM yang telah dilatih sebelumnya, memungkinkan pelatihan lebih cepat dan penyimpanan yang dioptimalkan. Untuk Difusi Stabil, adaptor dipasang ke encoder teks dan komponen U-Net dari pipa inferensi. Encoder teks mengubah prompt masukan menjadi ruang laten yang dipahami oleh model U-Net, dan model U-Net menggunakan makna laten untuk menghasilkan gambar dalam proses difusi berikutnya. Output dari penyempurnaan hanyalah text_encoder dan bobot adaptor U-Net. Pada saat inferensi, bobot ini dapat dipasang kembali ke model Difusi Stabil dasar untuk mereproduksi hasil penyesuaian.

Gambar di bawah ini adalah diagram detail penyempurnaan LoRA yang disediakan oleh penulis asli: Cheng-Han Chiang, Yung-Sung Chuang, Hung-yi Lee, “AACL_2022_tutorial_PLMs,” 2022

Dengan menggabungkan kedua metode, kami dapat menghasilkan model yang dipersonalisasi sambil menyetel parameter dengan urutan besarnya lebih sedikit. Hal ini menghasilkan waktu pelatihan yang jauh lebih cepat dan mengurangi penggunaan GPU. Selain itu, penyimpanan dioptimalkan dengan bobot adaptor yang hanya 70 MB, dibandingkan dengan 6 GB untuk model Difusi Stabil penuh, yang berarti pengurangan ukuran sebesar 99%.

Siapkan artefak model

Setelah penyesuaian selesai, langkah pascapemrosesan akan TAR bobot LoRA dengan model lainnya yang menyajikan file untuk NVIDIA Triton. Kami menggunakan backend Python, yang berarti file konfigurasi Triton dan skrip Python yang digunakan untuk inferensi diperlukan. Perhatikan bahwa skrip Python harus diberi nama model.py. File TAR model akhir harus memiliki struktur file berikut:

|--sd_lora |--config.pbtxt |--1 |--model.py |--output #LoRA weights |--text_encoder |--unet |--train.sh

Host model yang disempurnakan menggunakan MME SageMaker dengan GPU

Setelah model disempurnakan, kami menghosting model Difusi Stabil yang dipersonalisasi menggunakan SageMaker MME. MME SageMaker adalah fitur penerapan canggih yang memungkinkan hosting beberapa model dalam satu kontainer di belakang satu titik akhir. Ini secara otomatis mengelola lalu lintas dan perutean ke model Anda untuk mengoptimalkan pemanfaatan sumber daya, menghemat biaya, dan meminimalkan beban operasional dalam mengelola ribuan titik akhir. Dalam contoh kami, kami menjalankan instans GPU, dan MME SageMaker mendukung GPU menggunakan Server Triton. Hal ini memungkinkan Anda menjalankan beberapa model pada satu perangkat GPU dan memanfaatkan komputasi yang dipercepat. Untuk detail lebih lanjut tentang cara menghosting Difusi Stabil pada MME SageMaker, lihat Buat gambar berkualitas tinggi dengan model Difusi Stabil dan terapkan secara hemat biaya dengan Amazon SageMaker.

Sebagai contoh, kami melakukan pengoptimalan tambahan untuk memuat model yang telah disetel dengan lebih cepat selama situasi start dingin. Hal ini dimungkinkan karena desain adaptor LoRA. Karena bobot model dasar dan lingkungan Conda sama untuk semua model yang disempurnakan, kami dapat berbagi sumber daya umum ini dengan memuatnya terlebih dahulu ke dalam wadah hosting. Ini hanya menyisakan file konfigurasi Triton, backend Python (model.py), dan bobot adaptor LoRA yang akan dimuat secara dinamis dari Amazon S3 setelah pemanggilan pertama. Diagram berikut memberikan perbandingan berdampingan.

Hal ini secara signifikan mengurangi file model TAR dari sekitar 6 GB menjadi 70 MB, sehingga jauh lebih cepat untuk memuat dan membongkar. Untuk melakukan pramuat dalam contoh kita, kita membuat model backend utilitas Python models/model_setup. Skrip ini cukup menyalin model Difusi Stabil dasar dan lingkungan Conda dari Amazon S3 ke lokasi umum untuk dibagikan ke semua model yang telah disesuaikan. Berikut ini cuplikan kode yang melakukan tugas tersebut:

def initialize(self, args): #conda env setup self.conda_pack_path = Path(args['model_repository']) / "sd_env.tar.gz" self.conda_target_path = Path("/tmp/conda") self.conda_env_path = self.conda_target_path / "sd_env.tar.gz" if not self.conda_env_path.exists(): self.conda_env_path.parent.mkdir(parents=True, exist_ok=True) shutil.copy(self.conda_pack_path, self.conda_env_path) #base diffusion model setup self.base_model_path = Path(args['model_repository']) / "stable_diff.tar.gz" try: with tarfile.open(self.base_model_path) as tar: tar.extractall('/tmp') self.response_message = "Model env setup successful." except Exception as e: # print the exception message print(f"Caught an exception: {e}") self.response_message = f"Caught an exception: {e}"

Kemudian setiap model yang disempurnakan akan menunjuk ke lokasi bersama di container. Lingkungan Conda direferensikan dalam config.pbtxt.

name: "pipeline_0"
backend: "python"
max_batch_size: 1 ... parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "/tmp/conda/sd_env.tar.gz"}
}

Model dasar Difusi Stabil diambil dari initialize() fungsi masing-masing model.py mengajukan. Kami kemudian menerapkan bobot LoRA yang dipersonalisasi ke unet dan text_encoder model untuk mereproduksi setiap model yang disempurnakan:

... class TritonPythonModel: def initialize(self, args): self.output_dtype = pb_utils.triton_string_to_numpy( pb_utils.get_output_config_by_name(json.loads(args["model_config"]), "generated_image")["data_type"]) self.model_dir = args['model_repository'] device='cuda' self.pipe = StableDiffusionPipeline.from_pretrained('/tmp/stable_diff', torch_dtype=torch.float16, revision="fp16").to(device) # Load the LoRA weights self.pipe.unet = PeftModel.from_pretrained(self.pipe.unet, unet_sub_dir) if os.path.exists(text_encoder_sub_dir): self.pipe.text_encoder = PeftModel.from_pretrained(self.pipe.text_encoder, text_encoder_sub_dir)

import random prompt = """<<TOK>> epic portrait, zoomed out, blurred background cityscape, bokeh, perfect symmetry, by artgem, artstation ,concept art,cinematic lighting, highly detailed, octane, concept art, sharp focus, rockstar games, post processing, picture of the day, ambient lighting, epic composition""" negative_prompt = """
beard, goatee, ugly, tiling, poorly drawn hands, poorly drawn feet, poorly drawn face, out of frame, extra limbs, disfigured, deformed, body out of frame, blurry, bad anatomy, blurred, watermark, grainy, signature, cut off, draft, amateur, multiple, gross, weird, uneven, furnishing, decorating, decoration, furniture, text, poor, low, basic, worst, juvenile, unprofessional, failure, crayon, oil, label, thousand hands """ seed = random.randint(1, 1000000000) gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=7, seed=seed)) inputs = dict(prompt = prompt, negative_prompt = negative_prompt, gen_args = gen_args) payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
} response = sm_runtime.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_lora.tar.gz",
)
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
original_image = decode_image(output[0]["data"][0])
original_image

• 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/build-a-personalized-avatar-with-generative-ai-using-amazon-sagemaker/