โมเดลและอัลกอริทึม Amazon SageMaker JumpStart พร้อมใช้งานผ่าน API . แล้ว

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

ก่อนหน้านี้ เนื้อหา JumpStart ทั้งหมดมีให้เฉพาะผ่าน สตูดิโอ Amazon SageMakerซึ่งให้ ส่วนต่อประสานกราฟิกที่ใช้งานง่าย เพื่อโต้ตอบกับคุณสมบัติ วันนี้เรารู้สึกตื่นเต้นที่จะประกาศเปิดตัว easy-to-use JumpStart API เป็นส่วนขยายของ SageMaker Python SDK API เหล่านี้ช่วยให้คุณสามารถปรับใช้โดยทางโปรแกรมและปรับแต่งโมเดลที่ได้รับการฝึกฝนล่วงหน้าซึ่งรองรับ 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 ที่กำหนดเองและคีย์การเข้ารหัส KMS เพื่อให้คุณสามารถใช้โมเดลและโซลูชันที่มีอยู่ได้อย่างปลอดภัยภายในสภาพแวดล้อมองค์กรของคุณ คุณสามารถส่งการตั้งค่าความปลอดภัยของคุณไปที่ JumpStart ภายใน SageMaker Studio หรือผ่าน SageMaker Python SDK

งาน ML ที่รองรับ JumpStart และตัวอย่าง API Notebooks

ปัจจุบัน JumpStart รองรับงาน ML ยอดนิยม 15 งาน; 13 งานเป็นงานด้านวิสัยทัศน์และ NLP ซึ่ง 8 งานสนับสนุนการปรับแต่งแบบไม่มีโค้ด นอกจากนี้ยังรองรับอัลกอริธึมยอดนิยมสี่ตัวสำหรับการสร้างแบบจำลองข้อมูลแบบตาราง งานและลิงก์ไปยังสมุดบันทึกตัวอย่างได้สรุปไว้ในตารางต่อไปนี้

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

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

ปรับแต่งและปรับใช้โมเดลการตรวจจับวัตถุด้วย JumpStart APIs

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

เราดำเนินการตามขั้นตอนระดับสูงดังต่อไปนี้:

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

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

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

ดึงสิ่งประดิษฐ์ JumpStart และปรับใช้ปลายทาง

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

infer_model_id, infer_model_version = "pytorch-od-nvidia-ssd", "*" # Retrieve the inference docker container uri. This is the base container PyTorch image for the model selected above. deploy_image_uri = image_uris.retrieve(region=None, framework=None, image_scope="inference",model_id=infer_model_id, model_version=infer_model_version, instance_type=inference_instance_type) # Retrieve the inference script uri. This includes all dependencies and scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, script_scope="inference") # Retrieve the base model uri. This includes the pre-trained nvidia-ssd model and parameters.
base_model_uri = model_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, model_scope="inference")

ต่อไป เราป้อนทรัพยากรลงใน รุ่น 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", 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)

การปรับใช้ปลายทางอาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์

ค้นหาปลายทาง แยกวิเคราะห์การตอบสนอง และแสดงการคาดคะเน

ในการรับการอนุมานจากโมเดลที่ปรับใช้ อิมเมจอินพุตจะต้องจัดเตรียมในรูปแบบไบนารีพร้อมกับประเภทการยอมรับ ใน JumpStart คุณสามารถกำหนดจำนวนกล่องที่มีขอบเขตที่ส่งคืนได้ ในข้อมูลโค้ดต่อไปนี้ เราคาดคะเนกรอบขอบเขตสิบกล่องต่อภาพโดยการต่อท้าย ;n_predictions=10 ไปยัง Accept. ในการทำนายกล่อง xx คุณสามารถเปลี่ยนเป็น ;n_predictions=xx หรือรับกล่องที่คาดการณ์ทั้งหมดโดยละเว้น ;n_predictions=xx อย่างสิ้นเชิง

def query(model_predictor, image_file_name): with open(image_file_name, "rb") as file: input_img_rb = file.read() return model_predictor.predict(input_img_rb,{ "ContentType": "application/x-image", "Accept": "application/json;verbose;n_predictions=10"}) query_response = query(base_model_predictor, Naxos_Taverna)

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

normalized_boxes, classes_names, confidences = parse_response(query_response)
display_predictions(Naxos_Taverna, normalized_boxes, classes_names, confidences)

ภาพหน้าจอต่อไปนี้แสดงผลลัพธ์ของรูปภาพที่มีป้ายกำกับการคาดคะเนและกรอบล้อมรอบ

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

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

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

เรียกสิ่งประดิษฐ์การฝึกอบรม

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

train_model_id, train_model_version, train_scope = "mxnet-od-ssd-512-vgg16-atrous-coco","*","training"
training_instance_type = "ml.p2.xlarge" # Retrieve the docker image. This is the base container MXNet image for the model selected above. train_image_uri = image_uris.retrieve(region=None, framework=None, model_id=train_model_id, model_version=train_model_version, image_scope=train_scope,instance_type=training_instance_type) # Retrieve the training script and dependencies. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(model_id=train_model_id, model_version=train_model_version, script_scope=train_scope) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope)

ซ้อมวิ่ง

ในการรันการฝึกอบรม เราเพียงแค่ป้อนสิ่งประดิษฐ์ที่จำเป็นพร้อมกับพารามิเตอร์เพิ่มเติมบางอย่างไปที่a เครื่องมือประมาณการ SageMaker และเรียก .fit ฟังก์ชั่น:

# Create SageMaker Estimator instance
od_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", # Entry-point file in source_dir and present in train_source_uri. 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
od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

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

สรุป

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

เราหวังว่าจะได้รับการติดต่อจากคุณเมื่อคุณทดลองใช้ JumpStart

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

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

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

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

• คอยน์สมาร์ท การแลกเปลี่ยน Bitcoin และ Crypto ที่ดีที่สุดในยุโรป
• เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าฟรี
• คริปโตฮอว์ก เรดาร์ Altcoin ทดลองฟรี.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-jumpstart-models-and-algorithms-now-available-via-api/