ระบายสีรูปภาพด้วย Stable Diffusion โดยใช้ Amazon SageMaker JumpStart

ในเดือนพฤศจิกายน 2022 เรา ประกาศ ที่ลูกค้า AWS สามารถสร้างรูปภาพจากข้อความได้ การแพร่กระจายที่เสถียร รุ่นที่ใช้ Amazon SageMaker JumpStart. วันนี้เรารู้สึกตื่นเต้นที่จะแนะนำคุณลักษณะใหม่ที่ช่วยให้ผู้ใช้สามารถวาดภาพด้วยแบบจำลองการแพร่กระจายที่เสถียร การระบายสีหมายถึงกระบวนการแทนที่ส่วนหนึ่งของภาพด้วยภาพอื่นตามข้อความ ด้วยการจัดเตรียมภาพต้นฉบับ ภาพมาสก์ที่แสดงส่วนที่จะแทนที่ และข้อความแจ้ง โมเดล Stable Diffusion สามารถสร้างภาพใหม่ที่แทนที่พื้นที่มาสก์ด้วยวัตถุ เรื่อง หรือสภาพแวดล้อมที่อธิบายไว้ในข้อความข้อความ

คุณสามารถใช้การลงสีเพื่อฟื้นฟูภาพที่เสื่อมโทรมหรือสร้างภาพใหม่ด้วยหัวเรื่องหรือรูปแบบแปลกใหม่ในบางส่วน ภายในขอบเขตของการออกแบบสถาปัตยกรรม การพ่นสีแบบ Stable Diffusion สามารถนำไปใช้ในการซ่อมแซมส่วนที่ไม่สมบูรณ์หรือเสียหายของพิมพ์เขียวอาคาร โดยให้ข้อมูลที่แม่นยำสำหรับทีมงานก่อสร้าง ในกรณีของการถ่ายภาพ MRI ทางคลินิก ศีรษะของผู้ป่วยจะต้องถูกยับยั้งไว้ ซึ่งอาจนำไปสู่ผลลัพธ์ที่ต่ำกว่ามาตรฐานเนื่องจากการครอบตัดทำให้ข้อมูลสูญหายหรือความแม่นยำในการวินิจฉัยลดลง การลงสีรูปภาพสามารถช่วยลดผลลัพธ์ที่ไม่เหมาะสมเหล่านี้ได้อย่างมีประสิทธิภาพ

ในโพสต์นี้ เรานำเสนอคำแนะนำที่ครอบคลุมเกี่ยวกับการปรับใช้และการเรียกใช้การอนุมานโดยใช้แบบจำลองการพ่นสี Stable Diffusion ในสองวิธี: ผ่านส่วนต่อประสานผู้ใช้ (UI) ของ JumpStart ใน สตูดิโอ Amazon SageMakerและโดยทางโปรแกรมผ่าน JumpStart API มีอยู่ในไฟล์ SageMaker Python SDK.

ภาพรวมโซลูชัน

ภาพต่อไปนี้เป็นตัวอย่างของการลงสี ภาพต้นฉบับอยู่ทางซ้าย ภาพมาสก์อยู่ตรงกลาง และภาพที่วาดโดยโมเดลอยู่ทางขวา สำหรับตัวอย่างแรก นางแบบได้รับภาพต้นฉบับ ภาพหน้ากาก และข้อความ "แมวขาว ตาสีฟ้า สวมเสื้อกันหนาว นอนอยู่ในสวนสาธารณะ" รวมถึงข้อความปฏิเสธ "วาดเท้าไม่ดี ” สำหรับตัวอย่างที่สอง ข้อความแจ้งคือ “นางแบบสาวโชว์ชุดเดรสยาวลำลองที่ผสมผสานระหว่างเฉดสีชมพูและน้ำเงินอย่างสง่างามอย่างสง่างาม”

การเรียกใช้โมเดลขนาดใหญ่ เช่น Stable Diffusion ต้องใช้สคริปต์การอนุมานแบบกำหนดเอง คุณต้องเรียกใช้การทดสอบแบบ end-to-end เพื่อให้แน่ใจว่าสคริปต์ โมเดล และอินสแตนซ์ที่ต้องการทำงานร่วมกันได้อย่างมีประสิทธิภาพ JumpStart ทำให้กระบวนการนี้ง่ายขึ้นด้วยการจัดเตรียมสคริปต์ที่พร้อมใช้งานซึ่งได้รับการทดสอบอย่างเข้มงวด คุณสามารถเข้าถึงสคริปต์เหล่านี้ได้ด้วยคลิกเดียวผ่าน UI ของ Studio หรือใช้โค้ดเพียงไม่กี่บรรทัดผ่านทาง JumpStart API.

ส่วนต่อไปนี้จะแนะนำคุณตลอดการปรับใช้โมเดลและการเรียกใช้การอนุมานโดยใช้ Studio UI หรือ JumpStart API

โปรดทราบว่าการใช้โมเดลนี้แสดงว่าคุณยอมรับ ใบอนุญาต CreativeML Open RAIL++-M.

เข้าถึง JumpStart ผ่าน Studio UI

ในส่วนนี้ เราจะแสดงตัวอย่างการปรับใช้โมเดล JumpStart โดยใช้ Studio UI วิดีโอที่ให้มาแสดงตำแหน่งโมเดลการพ่นสี Stable Diffusion ที่ฝึกไว้ล่วงหน้าบน JumpStart และปรับใช้ หน้าโมเดลนำเสนอรายละเอียดที่จำเป็นเกี่ยวกับโมเดลและการใช้งาน ในการอนุมาน เราใช้ประเภทอินสแตนซ์ ml.p3.2xlarge ซึ่งให้การเร่ง GPU ที่จำเป็นสำหรับการอนุมานที่มีเวลาแฝงต่ำในราคาที่เหมาะสม หลังจากกำหนดค่าอินสแตนซ์การโฮสต์ SageMaker แล้ว ให้เลือก ปรับใช้. จุดสิ้นสุดจะทำงานและเตรียมพร้อมที่จะจัดการกับคำขอการอนุมานภายในเวลาประมาณ 10 นาที

JumpStart จัดเตรียมสมุดบันทึกตัวอย่างที่สามารถช่วยเร่งเวลาที่ใช้ในการเรียกใช้การอนุมานบนจุดสิ้นสุดที่สร้างขึ้นใหม่ หากต้องการเข้าถึงสมุดบันทึกใน Studio ให้เลือก เปิดสมุดบันทึก ใน ใช้ปลายทางจากสตูดิโอ ส่วนของหน้าจุดสิ้นสุดของโมเดล

ใช้ JumpStart โดยทางโปรแกรมกับ SageMaker SDK

การใช้ JumpStart UI ทำให้คุณสามารถปรับใช้โมเดลที่ได้รับการฝึกอบรมล่วงหน้าแบบโต้ตอบได้ด้วยการคลิกเพียงไม่กี่ครั้ง อีกทางหนึ่ง คุณสามารถใช้โมเดล JumpStart แบบเป็นโปรแกรมได้โดยใช้ API ที่รวมอยู่ภายใน SageMaker Python SDK

ในส่วนนี้ เราเลือกโมเดลที่ได้รับการฝึกอบรมล่วงหน้าที่เหมาะสมใน JumpStart ปรับใช้โมเดลนี้กับตำแหน่งข้อมูล SageMaker และทำการอนุมานบนตำแหน่งข้อมูลที่ใช้งาน ทั้งหมดนี้ใช้ SageMaker Python SDK ตัวอย่างต่อไปนี้มีข้อมูลโค้ด หากต้องการเข้าถึงรหัสที่สมบูรณ์พร้อมขั้นตอนทั้งหมดที่รวมอยู่ในการสาธิตนี้ โปรดดูที่ ข้อมูลเบื้องต้นเกี่ยวกับการแก้ไขรูปภาพ JumpStart – การพ่นสีแบบกระจายที่เสถียร ตัวอย่างโน๊ตบุ๊ค

ปรับใช้โมเดลที่ฝึกไว้ล่วงหน้า

SageMaker ใช้คอนเทนเนอร์ Docker สำหรับงานบิลด์และรันไทม์ต่างๆ JumpStart ใช้ คอนเทนเนอร์การเรียนรู้เชิงลึกของ SageMaker (DLCs) ที่เป็นกรอบเฉพาะ ขั้นแรก เราจะดึงแพ็คเกจเพิ่มเติม รวมถึงสคริปต์เพื่อจัดการการฝึกอบรมและการอนุมานสำหรับงานที่เลือก จากนั้นจะมีการดึงข้อมูลแบบจำลองที่ฝึกไว้ล่วงหน้าแยกจากกัน model_urisซึ่งให้ความยืดหยุ่นแก่แพลตฟอร์ม สิ่งนี้ทำให้สามารถใช้โมเดลที่ผ่านการฝึกอบรมล่วงหน้าหลายตัวกับสคริปต์การอนุมานเดียว รหัสต่อไปนี้แสดงกระบวนการนี้:

model_id, model_version = "model-inpainting-stabilityai-stable-diffusion-2-inpainting-fp16", "*"
# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, # automatically inferred from model_id image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
)
# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference") base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

ต่อไป เราจะมอบทรัพยากรเหล่านั้นให้กับ รุ่น SageMaker อินสแตนซ์และปรับใช้ปลายทาง:

# Create the SageMaker model instance
# Create the SageMaker model instance
model = Model( image_uri=deploy_image_uri, source_dir=deploy_source_uri, model_data=base_model_uri, entry_point="inference.py", # entry point file in source_dir and present in deploy_source_uri role=aws_role, predictor_cls=Predictor, name=endpoint_name,
) # deploy the Model - note that we need to pass the Predictor class when we deploy the model through the Model class,
# in order to run inference through the SageMaker API
base_model_predictor = model.deploy( initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name,
)

หลังจากปรับใช้โมเดลแล้ว เราสามารถรับการคาดการณ์ตามเวลาจริงได้!

อินพุต

อินพุตคือภาพฐาน ภาพมาสก์ และพรอมต์ที่อธิบายหัวเรื่อง วัตถุ หรือสภาพแวดล้อมที่จะแทนที่ในส่วนที่ปิดบัง การสร้างภาพมาสก์ที่สมบูรณ์แบบสำหรับเอฟเฟ็กต์ในการวาดภาพนั้นเกี่ยวข้องกับแนวทางปฏิบัติที่ดีที่สุดหลายประการ เริ่มต้นด้วยข้อความแจ้งที่เฉพาะเจาะจง และอย่าลังเลที่จะทดลองกับการตั้งค่าการแพร่กระจายแบบเสถียรต่างๆ เพื่อให้ได้ผลลัพธ์ที่ต้องการ ใช้ภาพมาสก์ที่ใกล้เคียงกับภาพที่คุณต้องการวาด วิธีการนี้ช่วยอัลกอริธึมการลงสีในการเติมส่วนที่ขาดหายไปของภาพ ทำให้ดูเป็นธรรมชาติมากขึ้น โดยทั่วไปรูปภาพคุณภาพสูงจะให้ผลลัพธ์ที่ดีกว่า ดังนั้นตรวจสอบให้แน่ใจว่ารูปภาพฐานและรูปภาพมาสก์ของคุณมีคุณภาพดีและคล้ายคลึงกัน นอกจากนี้ เลือกใช้ภาพมาสก์ขนาดใหญ่และเรียบเนียนเพื่อรักษารายละเอียดและลดส่วนผิดเพี้ยน

จุดสิ้นสุดจะยอมรับอิมเมจฐานและมาสก์เป็นค่าดิบ RGB หรืออิมเมจที่เข้ารหัส base64 ตัวจัดการการอนุมานถอดรหัสภาพตาม content_type:

• สำหรับ content_type = “application/json”เพย์โหลดอินพุตต้องเป็นพจนานุกรม JSON ที่มีค่า Raw RGB พร้อมท์ข้อความ และพารามิเตอร์ทางเลือกอื่นๆ
• สำหรับ content_type = “application/json;jpeg”เพย์โหลดอินพุตต้องเป็นพจนานุกรม JSON ที่มีรูปภาพเข้ารหัส base64 พร้อมท์ข้อความ และพารามิเตอร์ทางเลือกอื่นๆ

เอาท์พุต

จุดสิ้นสุดสามารถสร้างเอาต์พุตได้สองประเภท: อิมเมจ RGB ที่เข้ารหัส Base64 หรือพจนานุกรม JSON ของอิมเมจที่สร้างขึ้น คุณสามารถระบุรูปแบบผลลัพธ์ที่คุณต้องการได้โดยการตั้งค่า accept ส่วนหัวถึง "application/json" or "application/json;jpeg" สำหรับภาพ JPEG หรือ base64 ตามลำดับ

• สำหรับ accept = “application/json”จุดสิ้นสุดจะส่งคืนพจนานุกรม JSON ที่มีค่า RGB สำหรับรูปภาพ
• สำหรับ accept = “application/json;jpeg”จุดสิ้นสุดส่งคืนพจนานุกรม JSON พร้อมภาพ JPEG เป็นไบต์ที่เข้ารหัสด้วยการเข้ารหัส base64.b64

โปรดทราบว่าการส่งหรือรับเพย์โหลดด้วยค่า Raw RGB อาจถึงขีดจำกัดเริ่มต้นสำหรับเพย์โหลดอินพุตและขนาดการตอบสนอง ดังนั้น เราขอแนะนำให้ใช้ภาพที่เข้ารหัส base64 โดยการตั้งค่า content_type = “application/json;jpeg” และยอมรับ = “application/json;jpeg”

รหัสต่อไปนี้เป็นคำขออนุมานตัวอย่าง:

content_type = "application/json;jpeg" with open(input_img_file_name, "rb") as f: input_img_image_bytes = f.read()
with open(input_img_mask_file_name, "rb") as f: input_img_mask_image_bytes = f.read() encoded_input_image = base64.b64encode(bytearray(input_img_image_bytes)).decode()
encoded_mask = base64.b64encode(bytearray(input_img_mask_image_bytes)).decode() payload = { "prompt": "a white cat, blue eyes, wearing a sweater, lying in park", "image": encoded_input_image, "mask_image": encoded_mask, "num_inference_steps": 50, "guidance_scale": 7.5, "seed": 0, "negative_prompt": "poorly drawn feet",
} accept = "application/json;jpeg" def query(model_predictor, payload, content_type, accept): """Query the model predictor.""" query_response = model_predictor.predict( payload, { "ContentType": content_type, "Accept": accept, }, ) return query_response query_response = query(model_predictor, json.dumps(payload).encode("utf-8"), content_type, accept)
generated_images = parse_response(query_response)

พารามิเตอร์ที่รองรับ

แบบจำลองการพ่นสีแบบกระจายเสถียรรองรับพารามิเตอร์มากมายสำหรับการสร้างภาพ:

• ภาพ - ภาพต้นฉบับ
• หน้ากาก – ภาพที่ส่วนที่เป็นสีดำจะไม่เปลี่ยนแปลงในระหว่างการสร้างภาพ และส่วนที่เป็นสีขาวจะถูกแทนที่
• รวดเร็ว – พรอมต์เพื่อเป็นแนวทางในการสร้างภาพ อาจเป็นสตริงหรือรายการสตริงก็ได้
• num_inference_steps (ไม่บังคับ) – จำนวนขั้น denoising ระหว่างการสร้างภาพ ขั้นตอนมากขึ้นนำไปสู่ภาพที่มีคุณภาพสูงขึ้น หากระบุ จะต้องเป็นจำนวนเต็มบวก โปรดทราบว่าขั้นตอนการอนุมานเพิ่มเติมจะทำให้เวลาตอบสนองนานขึ้น
• Guidance_scale (ไม่บังคับ) – ระดับคำแนะนำที่สูงขึ้นส่งผลให้ภาพมีความเกี่ยวข้องอย่างใกล้ชิดกับข้อความแจ้งมากขึ้น โดยที่คุณภาพของภาพจะเสียไป หากระบุจะต้องเป็นแบบลอยตัว guidance_scale<=1 ถูกละเว้น
• Negative_prompt (ไม่บังคับ) – สิ่งนี้แนะนำการสร้างภาพเทียบกับพรอมต์นี้ หากระบุ จะต้องเป็นสตริงหรือรายการสตริงและใช้กับ guidance_scale. ถ้า guidance_scale ถูกปิดใช้งาน สิ่งนี้ก็ถูกปิดใช้งานเช่นกัน นอกจากนี้ หากพรอมต์เป็นรายการของสตริง แสดงว่า negative_prompt ต้องเป็นรายการของสตริงด้วย
• เมล็ดพันธุ์ (ไม่จำเป็น) – สิ่งนี้แก้ไขสถานะสุ่มสำหรับการทำซ้ำ หากระบุจะต้องเป็นจำนวนเต็ม เมื่อใดก็ตามที่คุณใช้พรอมต์เดียวกันกับเมล็ดเดียวกัน ภาพที่ได้จะเหมือนกันเสมอ
• batch_size (ไม่บังคับ) – จำนวนภาพที่จะสร้างขึ้นในการส่งต่อครั้งเดียว หากใช้อินสแตนซ์ขนาดเล็กหรือสร้างอิมเมจจำนวนมาก ให้ลดขนาดลง batch_size เป็นจำนวนน้อย (1–2) จำนวนภาพ = จำนวนพรอมต์*num_images_per_prompt.

ข้อจำกัดและความลำเอียง

แม้ว่า Stable Diffusion จะมีประสิทธิภาพที่น่าประทับใจในการพ่นสี แต่ก็มีข้อจำกัดและอคติหลายประการ ซึ่งรวมถึงแต่ไม่จำกัดเพียง:

• โมเดลอาจสร้างใบหน้าหรือแขนขาได้ไม่แม่นยำ เนื่องจากข้อมูลการฝึกมีรูปภาพที่มีคุณสมบัติเหล่านี้ไม่เพียงพอ
• แบบจำลองได้รับการฝึกอบรมเกี่ยวกับ ชุดข้อมูล LAION-5Bซึ่งมีเนื้อหาสำหรับผู้ใหญ่และอาจไม่เหมาะสำหรับการใช้ผลิตภัณฑ์โดยไม่ต้องพิจารณาเพิ่มเติม
• โมเดลอาจทำงานได้ไม่ดีกับภาษาที่ไม่ใช่ภาษาอังกฤษ เนื่องจากโมเดลได้รับการฝึกอบรมเกี่ยวกับข้อความภาษาอังกฤษ
• โมเดลไม่สามารถสร้างข้อความที่ดีภายในรูปภาพได้
• โดยทั่วไปการพ่นสีแบบกระจายที่เสถียรจะทำงานได้ดีที่สุดกับภาพที่มีความละเอียดต่ำ เช่น 256×256 หรือ 512×512 พิกเซล เมื่อทำงานกับภาพความละเอียดสูง (768×768 หรือสูงกว่า) วิธีการนี้อาจมีปัญหาในการรักษาระดับคุณภาพและรายละเอียดที่ต้องการ
• แม้ว่าการใช้เมล็ดพันธุ์จะช่วยควบคุมความสามารถในการทำซ้ำได้ แต่การพ่นสีแบบกระจายที่เสถียรอาจยังคงให้ผลลัพธ์ที่หลากหลายโดยมีการปรับเปลี่ยนอินพุตหรือพารามิเตอร์เล็กน้อย สิ่งนี้อาจทำให้ยากต่อการปรับแต่งผลลัพธ์อย่างละเอียดสำหรับข้อกำหนดเฉพาะ
• วิธีการนี้อาจมีปัญหากับการสร้างพื้นผิวและลวดลายที่ซับซ้อน โดยเฉพาะอย่างยิ่งเมื่อมันครอบคลุมพื้นที่ขนาดใหญ่ภายในภาพ หรือจำเป็นต่อการรักษาความสอดคล้องกันโดยรวมและคุณภาพของพื้นที่ที่ทาสี

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับข้อจำกัดและอคติ โปรดดูที่ การ์ดโมเดล Inpainting Diffusion ที่เสถียร.

โซลูชันการพ่นสีด้วยหน้ากากที่สร้างขึ้นผ่านข้อความแจ้ง

CLIPSeq เป็นเทคนิคการเรียนรู้เชิงลึกขั้นสูงที่ใช้พลังของโมเดล CLIP (Contrastive Language-Image Pretraining) ที่ฝึกไว้ล่วงหน้าเพื่อสร้างมาสก์จากภาพที่ป้อนเข้า วิธีนี้เป็นวิธีที่มีประสิทธิภาพในการสร้างมาสก์สำหรับงานต่างๆ เช่น การแบ่งส่วนภาพ การลงสี และการจัดการ CLIPSeq ใช้ CLIP เพื่อสร้างคำอธิบายข้อความของรูปภาพอินพุต คำอธิบายข้อความจะใช้เพื่อสร้างมาสก์ที่ระบุพิกเซลในภาพที่เกี่ยวข้องกับคำอธิบายข้อความ จากนั้นสามารถใช้มาสก์เพื่อแยกส่วนที่เกี่ยวข้องของภาพสำหรับการประมวลผลเพิ่มเติม

CLIPSeq มีข้อดีหลายประการเหนือวิธีอื่นๆ ในการสร้างมาสก์จากภาพอินพุต ประการแรก วิธีนี้เป็นวิธีที่มีประสิทธิภาพมากกว่า เนื่องจากไม่จำเป็นต้องประมวลผลรูปภาพด้วยอัลกอริทึมการแบ่งส่วนรูปภาพที่แยกต่างหาก ประการที่สอง มีความแม่นยำมากขึ้น เนื่องจากสามารถสร้างมาสก์ที่ใกล้เคียงกับคำอธิบายข้อความของรูปภาพมากขึ้น ประการที่สาม มีความหลากหลายมากกว่า เพราะคุณสามารถใช้สร้างมาสก์จากภาพที่หลากหลายได้

อย่างไรก็ตาม CLIPSeq ก็มีข้อเสียเช่นกัน ประการแรก เทคนิคอาจมีข้อจำกัดในแง่ของหัวข้อ เนื่องจากอาศัยโมเดล CLIP ที่ผ่านการฝึกอบรมมาล่วงหน้าซึ่งอาจไม่ครอบคลุมขอบเขตหรือพื้นที่ความเชี่ยวชาญเฉพาะด้าน ประการที่สอง อาจเป็นวิธีที่ละเอียดอ่อน เนื่องจากอาจมีข้อผิดพลาดในคำอธิบายข้อความของรูปภาพ

สำหรับข้อมูลเพิ่มเติมโปรดดูที่ จัดแต่งทรงผมเสมือนจริงด้วย AI กำเนิดโดยใช้ Amazon SageMaker.

ทำความสะอาด

หลังจากที่คุณเรียกใช้สมุดบันทึกเสร็จแล้ว ตรวจสอบให้แน่ใจว่าได้ลบทรัพยากรทั้งหมดที่สร้างขึ้นในกระบวนการเพื่อให้แน่ใจว่าการเรียกเก็บเงินจะหยุดลง รหัสสำหรับล้างข้อมูลปลายทางมีอยู่ในส่วนที่เกี่ยวข้อง สมุดบันทึก.

สรุป

ในโพสต์นี้ เราได้แสดงวิธีการปรับใช้โมเดลการพ่นสี Stable Diffusion ที่ฝึกไว้ล่วงหน้าโดยใช้ JumpStart เราได้แสดงตัวอย่างโค้ดในโพสต์นี้—โค้ดฉบับสมบูรณ์พร้อมขั้นตอนทั้งหมดในการสาธิตนี้มีอยู่ใน ข้อมูลเบื้องต้นเกี่ยวกับ JumpStart – ปรับปรุงคุณภาพของภาพตามคำแนะนำ ตัวอย่างโน๊ตบุ๊ค. ลองใช้วิธีแก้ปัญหาด้วยตัวคุณเองและส่งความคิดเห็นของคุณถึงเรา

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโมเดลและวิธีการทำงาน โปรดดูแหล่งข้อมูลต่อไปนี้:

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ JumpStart โปรดดูโพสต์ต่อไปนี้:

เกี่ยวกับผู้เขียน

ดร.วิเวก มะดัน เป็นนักวิทยาศาสตร์ประยุกต์กับทีม Amazon SageMaker JumpStart เขาสำเร็จการศึกษาระดับปริญญาเอกจากมหาวิทยาลัยอิลลินอยส์ Urbana-Champaign และเป็นนักวิจัยหลังปริญญาเอกที่ Georgia Tech เขาเป็นนักวิจัยเชิงรุกด้านการเรียนรู้ของเครื่องและการออกแบบอัลกอริธึม และได้ตีพิมพ์เอกสารในการประชุม EMNLP, ICLR, COLT, FOCS และ SODA

อัลเฟรด เชน เป็นผู้เชี่ยวชาญด้าน AI/ML อาวุโสที่ AWS เขาทำงานในซิลิคอน แวลลีย์ โดยดำรงตำแหน่งด้านเทคนิคและการจัดการในภาคส่วนต่าง ๆ รวมถึงการดูแลสุขภาพ การเงิน และเทคโนโลยีขั้นสูง เขาเป็นนักวิจัยประยุกต์ AI/ML โดยเฉพาะ โดยมุ่งเน้นที่ CV, NLP และการทำงานหลายรูปแบบ ผลงานของเขาได้รับการจัดแสดงในสื่อสิ่งพิมพ์ เช่น EMNLP, ICLR และ Public Health

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/inpaint-images-with-stable-diffusion-using-amazon-sagemaker-jumpstart/