เรียกใช้การแบ่งส่วนรูปภาพด้วย Amazon SageMaker JumpStart

ในเดือนธันวาคม 2020 AWS ประกาศ ความพร้อมทั่วไปของ Amazon SageMaker JumpStart, ความสามารถของ อเมซอน SageMaker ที่ช่วยให้คุณเริ่มต้นใช้งานแมชชีนเลิร์นนิง (ML) ได้อย่างรวดเร็วและง่ายดาย JumpStart ให้การปรับแต่งแบบละเอียดในคลิกเดียวและการปรับใช้โมเดลที่ได้รับการฝึกอบรมล่วงหน้าที่หลากหลายสำหรับงาน ML ยอดนิยม ตลอดจนการเลือกโซลูชันแบบ end-to-end ที่แก้ปัญหาทั่วไปทางธุรกิจ คุณลักษณะเหล่านี้ช่วยขจัดภาระหนักออกจากแต่ละขั้นตอนของกระบวนการ ML ทำให้ง่ายต่อการพัฒนาโมเดลคุณภาพสูงและลดเวลาในการปรับใช้

โพสต์นี้เป็นโพสต์ที่สามในซีรีส์เกี่ยวกับการใช้ JumpStart สำหรับงาน ML เฉพาะ ใน โพสต์แรกเราแสดงให้เห็นว่าคุณสามารถเรียกใช้กรณีการใช้งานการจัดประเภทรูปภาพบน JumpStart ได้อย่างไร ใน โพสต์ที่สองเราแสดงให้เห็นว่าคุณสามารถเรียกใช้กรณีการใช้งานการจัดประเภทข้อความบน JumpStart ได้อย่างไร ในโพสต์นี้ เรามีคำแนะนำทีละขั้นตอนเกี่ยวกับวิธีการปรับแต่งและปรับใช้โมเดลการแบ่งส่วนรูปภาพ โดยใช้โมเดลที่ได้รับการฝึกอบรมจาก MXNet เราสำรวจสองวิธีในการรับผลลัพธ์เดียวกัน: ผ่านอินเทอร์เฟซแบบกราฟิกของ JumpStart บน สตูดิโอ Amazon SageMakerและโดยทางโปรแกรมผ่าน JumpStart API.

หากคุณต้องการข้ามไปที่โค้ด JumpStart API ที่เราอธิบายในโพสต์นี้ คุณสามารถอ้างอิงถึงตัวอย่างสมุดบันทึก Jupyter ต่อไปนี้:

ภาพรวม JumpStart

JumpStart ช่วยให้คุณเริ่มต้นใช้งานโมเดล ML สำหรับงานที่หลากหลายโดยไม่ต้องเขียนโค้ดแม้แต่บรรทัดเดียว ในขณะที่เขียน JumpStart ให้คุณทำสิ่งต่อไปนี้:

• ปรับใช้โมเดลที่ได้รับการฝึกอบรมล่วงหน้าสำหรับงาน ML ทั่วไป – JumpStart ช่วยให้คุณจัดการกับงาน ML ทั่วไปโดยไม่ต้องพยายามพัฒนา โดยการปรับใช้โมเดลที่ฝึกอบรมล่วงหน้าบนชุดข้อมูลขนาดใหญ่ที่เปิดเผยต่อสาธารณะได้อย่างง่ายดาย ชุมชนการวิจัย ML ได้ใช้ความพยายามอย่างมากในการทำให้แบบจำลองที่พัฒนาล่าสุดส่วนใหญ่พร้อมใช้งานแบบสาธารณะ JumpStart มีคอลเลกชั่นมากกว่า 300 โมเดล ครอบคลุมงาน ML ยอดนิยม 15 งาน เช่น การตรวจจับวัตถุ การจัดประเภทข้อความ และการสร้างข้อความ ทำให้ง่ายสำหรับผู้เริ่มต้นใช้งาน โมเดลเหล่านี้มาจากฮับโมเดลยอดนิยม เช่น TensorFlow, PyTorch, Hugging Face และ MXNet
• ปรับแต่งรุ่นก่อนการฝึกอบรม – JumpStart ให้คุณปรับแต่งโมเดลที่ได้รับการฝึกมาล่วงหน้าโดยไม่จำเป็นต้องเขียนอัลกอริธึมการฝึกของคุณเอง ใน ML ความสามารถในการถ่ายทอดความรู้ที่เรียนรู้ในโดเมนหนึ่งไปยังอีกโดเมนหนึ่งเรียกว่า ถ่ายทอดการเรียนรู้. คุณสามารถใช้การเรียนรู้การถ่ายโอนเพื่อสร้างแบบจำลองที่แม่นยำบนชุดข้อมูลขนาดเล็กของคุณ โดยมีค่าใช้จ่ายการฝึกอบรมที่ต่ำกว่ามากเมื่อเทียบกับแบบจำลองที่เกี่ยวข้องกับการฝึกโมเดลดั้งเดิม JumpStart ยังรวมอัลกอริธึมการฝึกอบรมยอดนิยมตาม LightGBM, CatBoost, XGBoost และ Scikit-learn ซึ่งคุณสามารถฝึกตั้งแต่เริ่มต้นสำหรับการถดถอยแบบตารางและการจัดประเภท
• ใช้โซลูชันที่สร้างไว้ล่วงหน้า – JumpStart มีชุดโซลูชัน 17 ชุดสำหรับกรณีการใช้งาน ML ทั่วไป เช่น การคาดการณ์ความต้องการและแอปพลิเคชันด้านอุตสาหกรรมและการเงิน ซึ่งคุณสามารถปรับใช้ได้ด้วยการคลิกเพียงไม่กี่ครั้ง โซลูชันคือแอปพลิเคชัน ML แบบครบวงจรที่รวมบริการต่างๆ ของ AWS เพื่อแก้ปัญหากรณีการใช้งานทางธุรกิจโดยเฉพาะ พวกเขาใช้ การก่อตัวของ AWS Cloud เทมเพลตและสถาปัตยกรรมอ้างอิงเพื่อการปรับใช้อย่างรวดเร็ว ซึ่งหมายความว่าปรับแต่งได้อย่างเต็มที่
• ดูตัวอย่างสมุดบันทึกสำหรับอัลกอริธึม SageMaker – SageMaker มีชุดอัลกอริทึมในตัวเพื่อช่วยให้นักวิทยาศาสตร์ข้อมูลและผู้ปฏิบัติงาน ML เริ่มต้นการฝึกอบรมและปรับใช้โมเดล ML ได้อย่างรวดเร็ว JumpStart มีโน้ตบุ๊กตัวอย่างที่คุณสามารถใช้อัลกอริธึมเหล่านี้ได้อย่างรวดเร็ว
• ตรวจสอบวิดีโอการฝึกอบรมและบล็อก – JumpStart ยังมีโพสต์บล็อกและวิดีโอมากมายที่สอนวิธีใช้ฟังก์ชันต่างๆ ภายใน SageMaker

JumpStart ยอมรับการตั้งค่า VPC แบบกำหนดเองและ บริการจัดการคีย์ AWS คีย์การเข้ารหัส (AWS KMS) คุณจึงสามารถใช้โมเดลและโซลูชันที่มีอยู่ได้อย่างปลอดภัยภายในสภาพแวดล้อมองค์กรของคุณ คุณสามารถส่งการตั้งค่าความปลอดภัยของคุณไปที่ JumpStart ภายใน Studio หรือผ่าน SageMaker Python SDK

การแบ่งส่วนความหมาย

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

โมเดลที่พร้อมใช้งานสำหรับการปรับแต่งแบบละเอียดจะสร้าง "หัว" เครือข่ายแบบหมุนรอบอย่างสมบูรณ์ (FCN) ที่ด้านบนของเครือข่ายฐาน ขั้นตอนการปรับละเอียดจะปรับ FCNHead อย่างละเอียดในขณะที่คงพารามิเตอร์ของส่วนที่เหลือของแบบจำลองไว้ และส่งคืนแบบจำลองที่ปรับแต่งอย่างละเอียด วัตถุประสงค์คือเพื่อลดการสูญเสียเอนโทรปีข้ามของ softmax ต่อพิกเซลให้น้อยที่สุดเพื่อฝึก FCN โมเดลที่ส่งคืนโดยการปรับแต่งแบบละเอียดสามารถนำไปปรับใช้เพิ่มเติมสำหรับการอนุมานได้

ไดเร็กทอรีอินพุตควรมีลักษณะเหมือนโค้ดต่อไปนี้ หากข้อมูลการฝึกมีสองภาพ ชื่อของไฟล์ .png สามารถเป็นอะไรก็ได้

input_directory
    |--images
        |--abc.png
        |--def.png
    |--masks
        |--abc.png
        |--def.png
    class_label_to_prediction_index.json

ไฟล์มาสก์ควรมีข้อมูลป้ายกำกับคลาสสำหรับแต่ละพิกเซล

การแบ่งส่วนอินสแตนซ์

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

ปัจจุบัน JumpStart นำเสนอโมเดลการอนุมานเท่านั้นสำหรับการแบ่งกลุ่มอินสแตนซ์ และไม่รองรับการปรับแต่งแบบละเอียด

รูปภาพต่อไปนี้แสดงความแตกต่างระหว่างการอนุมานในการแบ่งส่วนความหมายและการแบ่งส่วนอินสแตนซ์ ภาพต้นฉบับมีคนสองคนอยู่ในภาพ การแบ่งส่วนความหมายปฏิบัติต่อบุคคลหลายคนในภาพเป็นเอนทิตีเดียว: Person. อย่างไรก็ตาม การแบ่งส่วนอินสแตนซ์จะระบุบุคคลภายใน Person หมวดหมู่

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

ส่วนต่อไปนี้เป็นการสาธิตทีละขั้นตอนเพื่อดำเนินการแบ่งกลุ่มตามความหมายด้วย JumpStart ทั้งผ่านทาง Studio UI และผ่าน JumpStart API

เราทำตามขั้นตอนต่อไปนี้:

1. เข้าถึง JumpStart ผ่าน Studio UI:
   1. เรียกใช้การอนุมานบนโมเดลที่ฝึกไว้ล่วงหน้า
   2. ปรับแต่งโมเดลที่ฝึกไว้ล่วงหน้าอย่างละเอียด
2. ใช้ JumpStart โดยทางโปรแกรมกับ SageMaker Python SDK:
   1. เรียกใช้การอนุมานบนโมเดลที่ฝึกไว้ล่วงหน้า
   2. ปรับแต่งโมเดลที่ฝึกไว้ล่วงหน้าอย่างละเอียด

เรายังพูดถึงคุณสมบัติขั้นสูงเพิ่มเติมของ JumpStart

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

ในส่วนนี้ เราสาธิตวิธีฝึกและปรับใช้โมเดล JumpStart ผ่าน Studio UI

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

วิดีโอต่อไปนี้แสดงวิธีค้นหาโมเดลการแบ่งส่วนความหมายล่วงหน้าใน JumpStart และปรับใช้ หน้าแบบจำลองประกอบด้วยข้อมูลที่มีค่าเกี่ยวกับแบบจำลอง วิธีใช้งาน รูปแบบข้อมูลที่คาดหวัง และรายละเอียดการปรับแต่งบางส่วน คุณสามารถปรับใช้โมเดลก่อนการฝึกอบรมใดๆ ที่มีอยู่ใน JumpStart สำหรับการอนุมาน เราเลือกประเภทอินสแตนซ์ ml.g4dn.xlarge มันให้การเร่งความเร็ว GPU ที่จำเป็นสำหรับเวลาแฝงการอนุมานต่ำ แต่ที่จุดราคาที่ต่ำกว่า หลังจากที่คุณกำหนดค่าอินสแตนซ์โฮสติ้ง SageMaker แล้ว ให้เลือก ปรับใช้. อาจใช้เวลา 5-10 นาทีจนกว่าปลายทางถาวรของคุณจะเริ่มทำงาน

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

ในทำนองเดียวกัน คุณสามารถปรับใช้โมเดลการแบ่งกลุ่มอินสแตนซ์ที่ได้รับการฝึกอบรมล่วงหน้าโดยทำตามขั้นตอนเดียวกันในวิดีโอก่อนหน้าขณะค้นหาการแบ่งกลุ่มอินสแตนซ์แทนการแบ่งส่วนความหมายในแถบค้นหา JumpStart

ปรับแต่งโมเดลที่ฝึกไว้ล่วงหน้าอย่างละเอียด

วิดีโอต่อไปนี้แสดงวิธีค้นหาและปรับแต่งโมเดลการแบ่งส่วนความหมายใน JumpStart ในวิดีโอ เราปรับแต่งโมเดลโดยใช้ปุ่ม ชุดข้อมูล PennFudanPedมีให้โดยค่าเริ่มต้นใน JumpStart ซึ่งคุณสามารถดาวน์โหลดได้ภายใต้ ใบอนุญาต Apache 2.0.

การปรับแต่งชุดข้อมูลของคุณอย่างละเอียดนั้นเกี่ยวข้องกับการจัดรูปแบบข้อมูลที่ถูกต้อง (ตามที่อธิบายไว้ในหน้าแบบจำลอง) การอัปโหลดไปยัง บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) และระบุตำแหน่งในการกำหนดค่าแหล่งข้อมูล เราใช้ค่าพารามิเตอร์ไฮเปอร์พารามิเตอร์เดียวกันตามค่าเริ่มต้น (จำนวนยุค อัตราการเรียนรู้ และขนาดแบทช์) เรายังใช้ ml.p3.2xlarge ที่สนับสนุน GPU เป็นอินสแตนซ์การฝึกอบรม SageMaker ของเราด้วย

คุณตรวจสอบงานการฝึกที่กำลังทำงานได้โดยตรงบนคอนโซล Studio และรับการแจ้งเตือนเมื่อเสร็จสิ้น หลังจากการฝึกอบรมเสร็จสิ้น คุณสามารถปรับใช้แบบจำลองที่ปรับแต่งแล้วจากหน้าเดียวกับที่มีรายละเอียดงานการฝึกอบรม เวิร์กโฟลว์การปรับใช้จะเหมือนกับการปรับใช้โมเดลที่ผ่านการฝึกอบรมล่วงหน้า

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

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

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

ในส่วนนี้ เราเลือกโมเดลที่ได้รับการฝึกฝนล่วงหน้าที่เหมาะสมใน JumpStart ปรับใช้โมเดลนี้กับตำแหน่งข้อมูล SageMaker และเรียกใช้การอนุมานบนจุดปลายที่ปรับใช้

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

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"

# 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")

ตัวอย่างเช่น การแบ่งส่วน เราสามารถตั้งค่า model_id ไปยัง mxnet-semseg-fcn-resnet50-ade. อยู่ในตัวระบุที่สอดคล้องกับการแบ่งส่วนอินสแตนซ์

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

# 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 Predictor class when we deploy model through Model class,
# for being able 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,
)

หลังจากนั้นไม่กี่นาที โมเดลของเราก็จะถูกปรับใช้และเราสามารถรับการคาดคะเนได้แบบเรียลไทม์!

ข้อมูลโค้ดต่อไปนี้ช่วยให้คุณเห็นคร่าวๆ ว่าการแบ่งเซ็กเมนต์เชิงความหมายเป็นอย่างไร มาสก์ที่คาดคะเนสำหรับแต่ละพิกเซลจะแสดงเป็นภาพ ในการรับการอนุมานจากโมเดลที่ปรับใช้ ต้องระบุอิมเมจอินพุตในรูปแบบไบนารี การตอบสนองของปลายทางเป็นป้ายกำกับที่คาดคะเนสำหรับแต่ละพิกเซลในรูปภาพ เราใช้ query_endpoint และ parse_response ฟังก์ชันตัวช่วยซึ่งกำหนดไว้ใน โน้ตบุ๊ค:

query_response = query(base_model_predictor, pedestrian_img)
predictions, labels, image_labels = parse_response(query_response)
print("Objects present in the picture:", image_labels)

ปรับแต่งโมเดลที่ฝึกไว้ล่วงหน้าอย่างละเอียด

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

from sagemaker import image_uris, model_uris, script_uris

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"
training_instance_type = "ml.p3.2xlarge"
train_image_uri = image_uris.retrieve(
    region=None,
    framework=None,
    model_id=model_id,
    model_version=model_version,
    image_scope="training",
    instance_type=training_instance_type,)# Retrieve the training script

train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")# Retrieve the pre-trained model tarball to further fine-tune

train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

เราดึง model_id ตรงตามรุ่นที่เราเคยใช้ ตอนนี้คุณสามารถปรับแต่งโมเดล JumpStart นี้บนชุดข้อมูลที่คุณกำหนดเองได้โดยใช้ SageMaker SDK เราใช้ชุดข้อมูลที่โฮสต์แบบสาธารณะใน Amazon S3 ซึ่งเน้นไปที่การแบ่งส่วนความหมายโดยสะดวก ชุดข้อมูลควรมีโครงสร้างสำหรับการปรับแต่งตามที่อธิบายไว้ในส่วนก่อนหน้า ดูโค้ดตัวอย่างต่อไปนี้:

# URI of your training dataset
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_SemSeg/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning")# Create SageMaker Estimator instance
semseg_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,)# Launch a SageMaker Training job by passing s3 path of the training data
semseg_estimator.fit({"training": training_dataset_s3_path}, logs=True)

เราได้รับไฮเปอร์พารามิเตอร์เริ่มต้นเดียวกันสำหรับโมเดลที่เลือกของเราเหมือนกับที่เราเห็นในส่วนก่อนหน้า โดยใช้ sagemaker.hyperparameters.retrieve_default(). จากนั้นเราจะยกตัวอย่างตัวประมาณ SageMaker และเรียก .fit วิธีการเริ่มปรับแต่งโมเดลของเราอย่างละเอียด โดยส่งต่อ Amazon S3 URI สำหรับข้อมูลการฝึกของเรา ดิ entry_point สคริปต์ที่ให้มามีชื่อว่า transfer_learning.py (เหมือนกันสำหรับงานและโมเดลอื่นๆ) และช่องข้อมูลอินพุตที่ส่งผ่านไปยัง .fit ต้องชื่อ training.

ขณะที่อัลกอริทึมฝึก คุณสามารถตรวจสอบความคืบหน้าได้ในโน้ตบุ๊ก SageMaker ที่คุณรันโค้ดเองหรือบน อเมซอน คลาวด์วอตช์. เมื่อการฝึกอบรมเสร็จสิ้น สิ่งประดิษฐ์ของโมเดลที่ปรับแต่งอย่างละเอียดจะถูกอัปโหลดไปยังตำแหน่งเอาต์พุต Amazon S3 ที่ระบุในการกำหนดค่าการฝึก ตอนนี้คุณสามารถปรับใช้โมเดลในลักษณะเดียวกับโมเดลที่ฝึกอบรมล่วงหน้า

คุณสมบัติขั้นสูง

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

ครั้งแรกคือ การปรับรุ่นอัตโนมัติ ซึ่งช่วยให้คุณปรับแต่งโมเดล ML ของคุณโดยอัตโนมัติเพื่อค้นหาค่าไฮเปอร์พารามิเตอร์ที่มีความแม่นยำสูงสุดภายในช่วงที่ให้ผ่าน SageMaker API

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

สรุป

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ JumpStart และวิธีที่คุณสามารถใช้โมเดลโอเพนซอร์สที่ได้รับการฝึกฝนล่วงหน้าสำหรับงาน ML อื่นๆ ที่หลากหลาย โปรดดูสิ่งต่อไปนี้ วิดีโอ AWS re:Invent 2020.

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

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

ซานโตส กุลคาร์นิ เป็น Enterprise Solutions Architect ที่ Amazon Web Services ซึ่งทำงานร่วมกับลูกค้าด้านกีฬาในออสเตรเลีย เขาหลงใหลในการสร้างแอปพลิเคชันแบบกระจายขนาดใหญ่เพื่อแก้ปัญหาทางธุรกิจโดยใช้ความรู้ด้าน AI/ML, บิ๊กดาต้า และการพัฒนาซอฟต์แวร์

เลโอนาร์โด บาเชก้า เป็นนักวิทยาศาสตร์อาวุโสและผู้จัดการในทีม Amazon SageMaker JumpStart เขาหลงใหลในการสร้างบริการ AI สำหรับคอมพิวเตอร์วิทัศน์