กระจายการปรับแต่งแบบจำลอง BERT ขนาดใหญ่สำหรับงานตอบคำถามโดยใช้ Hugging Face Transformers บน Amazon SageMaker

ประทับเวลา: 20 มกราคม 2022 2:30 น
โหนดต้นทาง: 1885069

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

ด้วยไลบรารีโอเพ่นซอร์ส Transformers และแพลตฟอร์ม ML Hugging Face ทำให้การเรียนรู้การถ่ายโอนและโมเดล ML ล่าสุดเข้าถึงได้โดยชุมชน AI ทั่วโลก ลดเวลาที่จำเป็นสำหรับนักวิทยาศาสตร์ข้อมูลและวิศวกร ML ในบริษัทต่างๆ ทั่วโลกในการใช้ประโยชน์จากวิทยาศาสตร์ใหม่ทั้งหมด ความก้าวหน้า

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

การปรับโมเดลอย่างละเอียดเพื่อสร้างการคาดการณ์ที่แม่นยำสำหรับปัญหาทางธุรกิจที่อยู่ในมือจำเป็นต้องมีการฝึกอบรมโมเดล Transformers ขนาดใหญ่ เช่น BERT, BART, RoBERTa, T5 ซึ่งอาจเป็นเรื่องท้าทายในการดำเนินการที่ปรับขนาดได้

Hugging Face ทำงานอย่างใกล้ชิดกับ SageMaker เพื่อส่งมอบ Deep Learning Containers ที่พร้อมใช้งาน (เนื้อหาดาวน์โหลด) ที่ทำให้การฝึกอบรมและการปรับใช้ Transformers รุ่นล่าสุดนั้นง่ายและรวดเร็วกว่าที่เคย เนื่องจากคุณลักษณะต่างๆ เช่น SageMaker Data Parallel (SMDP), SageMaker Model Parallel (SMMP), โหมดไพพ์ S3 ถูกรวมเข้าไว้ในคอนเทนเนอร์ การใช้คุณลักษณะเหล่านี้ช่วยลดเวลาได้อย่างมากสำหรับบริษัทในการสร้างโซลูชัน ML ที่ใช้ Transformers เช่น การตอบคำถาม การสร้าง ข้อความและรูปภาพ เพิ่มประสิทธิภาพผลการค้นหา และปรับปรุงระบบสนับสนุนลูกค้าอัตโนมัติ อินเทอร์เฟซการสนทนา การค้นหาความหมาย การวิเคราะห์เอกสาร และแอปพลิเคชันอื่นๆ อีกมากมาย

ในโพสต์นี้ เรามุ่งเน้นไปที่การผสานรวมเชิงลึกของไลบรารีแบบกระจายของ SageMaker กับ Hugging Face ซึ่งช่วยให้นักวิทยาศาสตร์ข้อมูลเร่งการฝึกอบรมและปรับแต่งโมเดล Transformers อย่างละเอียดจากวันเป็นชั่วโมง ทั้งหมดนี้ใน SageMaker

ภาพรวมของการฝึกอบรมแบบกระจาย

ผู้ปฏิบัติงานด้าน ML และนักวิทยาศาสตร์ข้อมูลเผชิญกับความท้าทายในการปรับขนาด XNUMX ประการเมื่อฝึกอบรมโมเดล: การปรับขนาดโมเดล (จำนวนพารามิเตอร์และเลเยอร์) และการปรับขนาดข้อมูลการฝึกอบรม การปรับขนาดโมเดลหรือข้อมูลการฝึกอบรมอาจส่งผลให้มีความแม่นยำมากขึ้น แต่อาจมีบางกรณีในการเรียนรู้เชิงลึกที่จำนวนหน่วยความจำบนตัวเร่งความเร็ว (CPU หรือ GPU) จำกัดการรวมกันของขนาดของข้อมูลการฝึกอบรมและขนาดของ แบบอย่าง. ตัวอย่างเช่น เมื่อฝึกโมเดลภาษาขนาดใหญ่ ขนาดแบทช์มักถูกจำกัดไว้ที่ตัวอย่างจำนวนเล็กน้อย ซึ่งอาจส่งผลให้โมเดลมีความแม่นยำน้อยลง

การฝึกแบบกระจายสามารถแบ่งเวิร์กโหลดเพื่อฝึกโมเดลระหว่างโปรเซสเซอร์หลายตัว ซึ่งเรียกว่า แรงงาน. พนักงานเหล่านี้ทำงานควบคู่กันไปเพื่อเร่งการฝึกอบรมแบบจำลอง

ขึ้นอยู่กับสิ่งที่เราต้องการปรับขนาด (แบบจำลองหรือข้อมูล) มีสองวิธีในการฝึกอบรมแบบกระจาย: แบบขนานข้อมูลและแบบขนาน.

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

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

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

เบื้องต้น

ในการดำเนินการฝึกอบรมแบบจำลอง Hugging Face Transformers แบบกระจายใน SageMaker คุณต้องดำเนินการตามข้อกำหนดเบื้องต้นต่อไปนี้:

ใช้การฝึกอบรมแบบกระจาย

ไลบรารี Hugging Face Transformers มี Trainer API ที่ได้รับการปรับให้เหมาะสมเพื่อฝึกหรือปรับแต่งโมเดลที่ไลบรารีมีให้ คุณยังสามารถใช้กับโมเดลของคุณเองได้ หากพวกมันทำงานแบบเดียวกับโมเดล Transformers; ดู ครูฝึก สำหรับรายละเอียดเพิ่มเติม API นี้ใช้ในของเรา สคริปต์ตัวอย่างซึ่งแสดงวิธีประมวลผลข้อมูลล่วงหน้าสำหรับงาน NLP ต่างๆ ซึ่งคุณสามารถใช้เป็นแบบจำลองในการเขียนสคริปต์เพื่อแก้ปัญหาที่คุณกำหนดเองได้ คำมั่นสัญญาของ Trainer API คือสคริปต์นี้ทำงานนอกกรอบในการตั้งค่าแบบกระจายใดๆ รวมถึง SageMaker

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

เบื้องหลัง Trainer API เริ่มต้นด้วยการวิเคราะห์สภาพแวดล้อมที่คุณกำลังเรียกใช้สคริปต์ของคุณเมื่อคุณสร้าง TrainingArguments. ตัวอย่างเช่น หากคุณเริ่มการฝึกอบรมด้วย SageMaker ระบบจะดูที่ SM_FRAMEWORK_PARAMS ตัวแปรในสภาพแวดล้อมเพื่อตรวจสอบว่าคุณเปิดใช้งานความขนานของข้อมูล SageMaker หรือความขนานของแบบจำลอง จากนั้นจะได้รับตัวแปรที่เกี่ยวข้อง (เช่น อันดับของกระบวนการหรือขนาดโลก) จากสภาพแวดล้อมก่อนที่จะดำเนินการขั้นตอนการเริ่มต้นที่จำเป็น (เช่น smdistributed.dataparallel.torch.distributed.init_process_group()).

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

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

เมื่อใช้วิธีประเมินและคาดการณ์ Trainer จะทำการประเมินแบบกระจายเพื่อใช้ประโยชน์จาก GPU ทั้งหมดของคุณ มันจัดการแยกข้อมูลของคุณสำหรับแต่ละกระบวนการอย่างเหมาะสม (กระบวนการเดียวกัน dp_rank หากเปิดใช้งานแบบจำลองคู่ขนาน) และตรวจสอบให้แน่ใจว่าการคาดการณ์นั้นรวบรวมอย่างถูกต้องในลำดับเดียวกับชุดข้อมูลที่คุณใช้ก่อนที่จะส่งไปยัง compute_metrics ฟังก์ชั่นหรือเพิ่งกลับมา การใช้ Trainer API นั้นไม่จำเป็น ผู้ใช้ยังคงสามารถใช้ Keras หรือ PyTorch ภายใน Hugging Face ได้ อย่างไรก็ตาม Trainer API สามารถจัดเตรียมเลเยอร์นามธรรมที่เป็นประโยชน์ได้

ฝึกโมเดลโดยใช้ SageMaker Hugging Face Estimators

Estimator เป็นอินเทอร์เฟซระดับสูงสำหรับการฝึกอบรม SageMaker และจัดการการฝึกอบรมและงานการปรับใช้ SageMaker ตั้งแต่ต้นจนจบ การฝึกสคริปต์ของคุณจะถูกเรียกใช้เมื่อคุณโทร fit เมื่อ HuggingFace ตัวประมาณ ใน Estimator คุณจะกำหนดว่าจะใช้สคริปต์การปรับแต่งแบบใด entry_pointซึ่ง instance_type ที่จะใช้ และไฮเปอร์พารามิเตอร์ใดบ้างที่ส่งผ่าน สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ HuggingFace พารามิเตอร์ ดู ตัวประมาณการกอดใบหน้า.

การฝึกอบรมแบบกระจาย: ข้อมูลคู่ขนาน

ในตัวอย่างนี้ เราใช้ Hugging Face DLC ใหม่และ SageMaker SDK เพื่อฝึกโมเดล Seq2Seq-transformer แบบกระจายในงานคำถามและคำตอบโดยใช้ไลบรารี Transformers และชุดข้อมูล เดอะ bert-ใหญ่-ไม่ใส่-ทั้งคำ-กำบัง โมเดลได้รับการปรับแต่งอย่างละเอียดบน ทีม ชุดข้อมูล

ตัวอย่างโค้ดต่อไปนี้แสดงขั้นตอนการสร้าง HuggingFace ตัวประมาณสำหรับการฝึกอบรมแบบกระจายพร้อมความขนานของข้อมูล

  1. เลือกสคริปต์ Hugging Face Transformers: 
    # git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'}

เมื่อคุณสร้างไฟล์ HuggingFace Estimator คุณสามารถระบุสคริปต์การฝึกอบรมที่เก็บอยู่ในที่เก็บ GitHub เป็นจุดเริ่มต้นสำหรับ Estimator ดังนั้นคุณจึงไม่ต้องดาวน์โหลดสคริปต์ในเครื่อง คุณสามารถใช้ได้ git_config เพื่อรันสคริปต์ตัวอย่าง Hugging Face Transformers และ 'branch' ทางขวาหากคุณ transformers_version ต้องมีการกำหนดค่า ตัวอย่างเช่น ถ้าคุณใช้ transformers_version 4.6.1 คุณต้องใช้ 'branch':'v4.6.1'

  1. กำหนดค่าไฮเปอร์พารามิเตอร์การฝึกที่ส่งผ่านไปยังงานการฝึก: 
    # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path': 'bert-large-uncased-whole-word-masking', 'dataset_name':'squad', 'do_train': True, 'do_eval': True, 'fp16': True, 'per_device_train_batch_size': 4, 'per_device_eval_batch_size': 4, 'num_train_epochs': 2, 'max_seq_length': 384, 'max_steps': 100, 'pad_to_max_length': True, 'doc_stride': 128, 'output_dir': '/opt/ml/model'
}

ในฐานะที่เป็นไฮเปอร์พารามิเตอร์ เราสามารถกำหนดอะไรก็ได้ Seq2SeqTrainingอาร์กิวเมนต์ และที่กำหนดไว้ในสคริปต์การฝึกอบรม

  1. กำหนดพารามิเตอร์การกระจายใน HuggingFace ประมาณการ: 
    # configuration for running training on smdistributed Data Parallel
distribution = {'smdistributed':{'dataparallel':{ 'enabled': True }}}

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

  1. สร้าง HuggingFace ตัวประมาณรวมถึงพารามิเตอร์ที่กำหนดไว้ในขั้นตอนก่อนหน้าและเริ่มการฝึกอบรม:
from sagemaker.huggingface import HuggingFace
# estimator
huggingface_estimator = HuggingFace(entry_point='run_qa.py', source_dir='./examples/pytorch/question-answering', git_config=git_config, instance_type= 'ml.p3.16xlarge', instance_count= 2, volume_size= 200, role= <SageMaker Role>, # IAM role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', distribution= distribution, hyperparameters = hyperparameters) # starting the train job huggingface_estimator.fit()

พื้นที่ ที่เก็บ Hugging Face Transformers มีตัวอย่างและสคริปต์มากมายสำหรับการปรับแต่งแบบจำลองในงานตั้งแต่การสร้างแบบจำลองภาษาไปจนถึงการจัดประเภทโทเค็น ในกรณีของเรา เราใช้ run_qa.py จาก examples/pytorch/question-answering ตัวอย่าง.

smdistributed.dataparallel สนับสนุนการฝึกอบรมแบบจำลองบน SageMaker ด้วย ประเภทอินสแตนซ์ต่อไปนี้เท่านั้น. เพื่อประสิทธิภาพที่ดีที่สุด ขอแนะนำให้ใช้ประเภทอินสแตนซ์ที่รองรับ อะแดปเตอร์ผ้ายืดหยุ่น (เอฟเอ):

  • ml.p3.16xlarge
  • ml.p3dn.24xlarge (แนะนำ)
  • ml.p4d.24xlarge (แนะนำ)

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

ดังต่อไปนี้ ตัวอย่างโน๊ตบุ๊ค ให้คำแนะนำทีละขั้นตอนโดยละเอียดยิ่งขึ้น

การฝึกอบรมแบบกระจาย: แบบขนาน

สำหรับการฝึกอบรมแบบกระจายที่มีความเท่าเทียมกันของแบบจำลอง เราใช้ Hugging Face Transformers และไลบรารีชุดข้อมูลร่วมกับ SageMaker SDK สำหรับการจำแนกลำดับบน การประเมินความเข้าใจภาษาทั่วไป (GLUE) การวัดประสิทธิภาพบนคลัสเตอร์แบบหลายโหนดและหลาย GPU โดยใช้ ไลบรารีการขนานแบบจำลอง SageMaker.

เช่นเดียวกับความขนานของข้อมูล ก่อนอื่นเราจะตั้งค่าคอนฟิกูเรชัน git การฝึกไฮเปอร์พารามิเตอร์ และพารามิเตอร์การกระจายใน HuggingFace ประมาณการ:

# git configuration to download our fine-tuning script
git_config = {'repo': 'https://github.com/huggingface/transformers.git','branch': 'v4.6.1'} # hyperparameters, which are passed into the training job
hyperparameters={ 'model_name_or_path':'roberta-large', 'task_name': 'mnli', 'per_device_train_batch_size': 16, 'per_device_eval_batch_size': 16, 'do_train': True, 'do_eval': True, 'do_predict': True, 'num_train_epochs': 2, 'output_dir':'/opt/ml/model', 'max_steps': 500,
} # configuration for running training on smdistributed Model Parallel
mpi_options = { "enabled" : True, "processes_per_host" : 8,
}
smp_options = { "enabled":True, "parameters": { "microbatches": 4, "placement_strategy": "spread", "pipeline": "interleaved", "optimize": "speed", "partitions": 4, "ddp": True, }
} distribution={ "smdistributed": {"modelparallel": smp_options}, "mpi": mpi_options
}

ไลบรารีการขนานของแบบจำลองใช้ MPI ภายใน ดังนั้นหากต้องการใช้การขนานของแบบจำลอง ต้องเปิดใช้งาน MPI โดยใช้พารามิเตอร์การกระจาย “processes_per_host” ในรหัสก่อนหน้านี้ระบุจำนวนของกระบวนการที่ MPI ควรเปิดใช้ในแต่ละโฮสต์ เราขอแนะนำสิ่งเหล่านี้สำหรับการพัฒนาและการทดสอบ ในขณะใช้งานจริง คุณสามารถติดต่อฝ่ายสนับสนุนของ AWS ได้ หากต้องการขอความจุ GPU จำนวนมาก สำหรับข้อมูลเพิ่มเติม โปรดดูที่ เรียกใช้งานการฝึกอบรมแบบคู่ขนานของ SageMaker แบบกระจาย.

ดังต่อไปนี้ ตัวอย่างโน๊ตบุ๊ค มีสคริปต์รหัสที่สมบูรณ์

อินสแตนซ์ของสปอต

ด้วยส่วนขยายเฟรมเวิร์ก Hugging Face สำหรับ SageMaker Python SDK เรายังสามารถใช้ประโยชน์จากการจัดการเต็มรูปแบบได้อีกด้วย อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (อเมซอน อีซี2) อินสแตนซ์ของสปอต และประหยัดได้ถึง 90% ของค่าใช้จ่ายในการฝึกอบรมของเรา

เว้นแต่งานฝึกอบรมของคุณจะเสร็จสิ้นอย่างรวดเร็ว เราขอแนะนำให้คุณใช้ จุดตรวจ ด้วยการฝึกอบรมเฉพาะจุด ดังนั้นคุณต้องกำหนด checkpoint_s3_uri.

หากต้องการใช้อินสแตนซ์ Spot กับ HuggingFace Estimator เราต้องตั้งค่า use_spot_instances พารามิเตอร์เป็น True และกำหนดของคุณ max_wait และ max_run เวลา. สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวงจรการฝึกอบรมเฉพาะจุดที่มีการจัดการ โปรดดู การฝึกอบรมเฉพาะจุดที่มีการจัดการใน Amazon SageMaker.

ต่อไปนี้เป็นข้อมูลโค้ดสำหรับการตั้งค่าตัวประมาณการฝึกอบรมเฉพาะจุด:

from sagemaker.huggingface import HuggingFace # hyperparameters, which are passed into the training job
hyperparameters={'epochs': 1, 'train_batch_size': 32, 'model_name':'distilbert-base-uncased', 'output_dir':'/opt/ml/checkpoints' } # s3 uri where our checkpoints will be uploaded during training
job_name = "using-spot"
checkpoint_s3_uri = f's3://{sess.default_bucket()}/{job_name}/checkpoints' huggingface_estimator = HuggingFace(entry_point='train.py', source_dir='./scripts', instance_type='ml.p3.2xlarge', instance_count=1, base_job_name=job_name, checkpoint_s3_uri=checkpoint_s3_uri, use_spot_instances=True, max_wait=3600, # This should be equal to or greater than max_run in seconds' max_run=1000, # expected max run in seconds role=role, transformers_version='4.6', pytorch_version='1.7', py_version='py36', hyperparameters = hyperparameters)

ดังต่อไปนี้ สมุดบันทึก มีสคริปต์รหัสที่สมบูรณ์

สรุป

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

ในกรณีการใช้งานแบบขนานของข้อมูลที่เราพูดถึง การฝึกโมเดลบนอินสแตนซ์ p3.2xlarge เดียว (ด้วย GPU เดียว) ใช้เวลา 4 ชั่วโมงและมีค่าใช้จ่ายประมาณ 15 ดอลลาร์ในขณะที่เขียนบทความนี้ ด้วยความเท่าเทียมกันของข้อมูล เราสามารถฝึกโมเดลเดียวกันได้ภายใน 24 นาทีโดยมีค่าใช้จ่าย 28 ดอลลาร์ แม้ว่าค่าใช้จ่ายจะเพิ่มขึ้นเป็นสองเท่า แต่วิธีนี้ทำให้เวลาการฝึกลดลงถึง 10 เท่า สำหรับสถานการณ์ที่คุณต้องฝึกโมเดลจำนวนมากภายในระยะเวลาสั้นๆ การขนานข้อมูลสามารถเปิดใช้งานสิ่งนี้ได้ด้วยต้นทุนที่เพิ่มขึ้นค่อนข้างต่ำ สำหรับกรณีการใช้งานแบบขนานนั้นจะเพิ่มความสามารถในการฝึกโมเดลที่ไม่เคยได้รับการฝึกฝนมาก่อนเนื่องจากข้อจำกัดของฮาร์ดแวร์ ฟีเจอร์ทั้งสองช่วยให้เวิร์กโฟลว์ใหม่สำหรับผู้ปฏิบัติงานด้าน ML และสามารถเข้าถึงได้ง่ายผ่านทาง HuggingFace เครื่องมือประมาณค่าเป็นส่วนหนึ่งของ SageMaker Python SDK การปรับใช้โมเดลเหล่านี้กับปลายทางที่โฮสต์มีขั้นตอนเดียวกับเครื่องมือประมาณค่าอื่นๆ

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

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

อาร์คิส โจเกลการ์ เป็นสถาปนิก AI/ML Partner Solutions Architect ในทีม Emerging Technologies เขาสนใจในการเรียนรู้เชิงลึกที่มีประสิทธิภาพ ปรับขนาดได้ และการคำนวณทางวิทยาศาสตร์โดยใช้หน่วยการสร้างที่ AWS ประสบการณ์ที่ผ่านมาของเขามีตั้งแต่การวิจัยฟิสิกส์เชิงคำนวณไปจนถึงการพัฒนาแพลตฟอร์มการเรียนรู้ด้วยเครื่องในสถาบันการศึกษา ห้องปฏิบัติการระดับประเทศ และการเริ่มต้น เวลาว่างจากคอมพิวเตอร์คือการเล่นฟุตบอลกับเพื่อนและครอบครัว

เจมส์ ยี่ เป็น Sr. AI/ML Partner Solutions Architect ในทีม Emerging Technologies ที่ Amazon Web Services เขาหลงใหลในการทำงานร่วมกับลูกค้าองค์กรและพันธมิตรในการออกแบบ ปรับใช้ และปรับขนาดแอปพลิเคชัน AI/ML เพื่อให้ได้คุณค่าทางธุรกิจ นอกเวลางาน เขาชอบเล่นฟุตบอล ท่องเที่ยว และใช้เวลากับครอบครัว

ฟิลิปป์ ชมิด เป็นวิศวกรแมชชีนเลิร์นนิงและหัวหน้าด้านเทคนิคที่ Hugging Face ซึ่งเขาเป็นผู้นำในการทำงานร่วมกันกับทีม Amazon SageMaker เขาหลงใหลเกี่ยวกับการทำให้เป็นประชาธิปไตย การเพิ่มประสิทธิภาพ และการผลิตแบบจำลอง NLP ที่ล้ำสมัย และปรับปรุงความง่ายในการใช้งานสำหรับการเรียนรู้เชิงลึก

ซิลแว็ง กุกเกอร์ เป็นวิศวกรวิจัยที่ Hugging Face และเป็นหนึ่งในผู้ดูแลหลักของห้องสมุด Transformers เขารักซอฟต์แวร์โอเพ่นซอร์สและช่วยให้ชุมชนใช้งานได้

เจฟฟ์ บูดิเยร์ สร้างผลิตภัณฑ์ที่ Hugging Face ผู้สร้าง Transformers ไลบรารี ML โอเพ่นซอร์สชั้นนำ ก่อนหน้านี้ เจฟฟ์เคยเป็นผู้ร่วมก่อตั้ง Stupeflix ซึ่งถูกซื้อกิจการโดย GoPro ซึ่งเขาดำรงตำแหน่งผู้อำนวยการฝ่ายการจัดการผลิตภัณฑ์ การตลาดผลิตภัณฑ์ การพัฒนาธุรกิจ และการพัฒนาองค์กร

ที่มา: https://aws.amazon.com/blogs/machine-learning/distributed-fine-tuning-of-a-bert-large-model-for-a-question-answering-task-using-hugging-face- Transformers-on-Amazon-sagemaker/

ประทับเวลา:

เพิ่มเติมจาก บล็อก AWS Machine Learning