การฝึกอบรมที่เพิ่มขึ้นด้วย Amazon SageMaker JumpStart

เผยแพร่ซ้ำโดยเพลโต

ผู้ติดตาม: 0

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

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

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

ภาพรวม JumpStart

JumpStart เป็นผลิตภัณฑ์แบบหลายแง่มุมที่มีความสามารถที่แตกต่างกันเพื่อช่วยให้คุณเริ่มต้นใช้งาน ML บน SageMaker ได้อย่างรวดเร็ว ในขณะที่เขียน JumpStart ให้คุณทำสิ่งต่อไปนี้:

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

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

การจำแนกรูปภาพ

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

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

input_directory |--roses |--abc.jpg |--def.jpg |--dandelion |--ghi.jpg |--jkl.jpg

ชื่อของโฟลเดอร์ คลาส และชื่อไฟล์ .jpg สามารถเป็นอะไรก็ได้

เราให้บริการ tf_flowers¹ชุดข้อมูลเป็นชุดข้อมูลเริ่มต้นสำหรับการปรับแต่งโมเดลอย่างละเอียด ชุดข้อมูลนี้ประกอบด้วยรูปภาพดอกไม้ห้าประเภท ดาวน์โหลดชุดข้อมูลจาก .แล้ว TensorFlow.

ภาพรวมคำแนะนำ Walk

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

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

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

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

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

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

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

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

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

คุณตรวจสอบงานการฝึกอบรมได้โดยตรงบนคอนโซล Studio และจะได้รับแจ้งเมื่อเสร็จสิ้น

ปรับใช้แบบจำลองที่ปรับแต่งอย่างละเอียด

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

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

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

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

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

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

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

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

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

from sagemaker import image_uris, model_uris, script_uris model_id, model_version = "pytorch-ic-mobilenet-v2", "1.0.0"
training_instance_type = "ml.p3.2xlarge" # Retrieve the docker image
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 เราก็ใช้เหมือนกัน tf_flowers ชุดข้อมูลที่โฮสต์แบบสาธารณะใน Amazon S3 ซึ่งเน้นไปที่การวิเคราะห์ความเชื่อมั่นอย่างสะดวก ชุดข้อมูลของคุณควรมีโครงสร้างสำหรับการปรับแต่งตามที่อธิบายไว้ในส่วนก่อนหน้า ดูโค้ดตัวอย่างต่อไปนี้:

# URI of your training dataset
training_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tf_flowers/"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning") # Create SageMaker Estimator instance
ic_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
ic_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.

การปรับใช้แบบจำลองที่ปรับแต่งอย่างละเอียด

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

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, 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"
) endpoint_name = name_from_base(f"jumpstart-example-FT-{model_id}-") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = ic_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

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

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

query_response = finetuned_predictor.predict( img, {"ContentType": "application/x-image", "Accept": "application/json;verbose"} )
model_predictions = json.loads(query_response)
predicted_label = model_predictions["predicted_label"]
display( HTML( f'<img src={image_filename} alt={image_filename} align="left" style="width: 250px;"/>' f"<figcaption>Predicted Label: {predicted_label}</figcaption>" )
)

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

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

last_trained_model_path = f"{s3_output_location}/{last_training_job_name}/output/model.tar.gz"
incremental_s3_output_location = f"s3://{output_bucket}/{incremental_output_prefix}/output"incremental_train_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=last_trained_model_path, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=incremental_s3_output_location, base_job_name=incremental_training_job_name,
) incremental_train_estimator.fit({"training": training_dataset_s3_path}, logs=True)

เมื่อการฝึกอบรมเสร็จสิ้น เราสามารถใช้ขั้นตอนเดียวกับที่อธิบายไว้ในส่วนก่อนหน้าเพื่อปรับใช้โมเดล

สรุป

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

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

อ้างอิง

ทีมงาน TensorFlow, 2019

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

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

ชูเอา มูร่า เป็นสถาปนิกโซลูชันผู้เชี่ยวชาญ AI/ML ที่ Amazon Web Services เขามุ่งเน้นไปที่กรณีการใช้งาน NLP เป็นส่วนใหญ่ และช่วยให้ลูกค้าปรับการฝึกอบรมและปรับใช้โมเดลการเรียนรู้เชิงลึกให้เหมาะสมที่สุด เขายังเป็นผู้สนับสนุนโซลูชัน ML แบบ low-code และฮาร์ดแวร์เฉพาะสำหรับ ML

ดร. Ashish Khetan เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสด้วย Amazon SageMaker JumpStart และ อัลกอริทึมในตัวของ Amazon SageMaker และช่วยพัฒนาอัลกอริธึมการเรียนรู้ของเครื่อง เขาเป็นนักวิจัยเชิงรุกด้านการเรียนรู้ของเครื่องและการอนุมานทางสถิติ และได้ตีพิมพ์บทความจำนวนมากในการประชุม NeurIPS, ICML, ICLR, JMLR, ACL และ EMNLP