เรียกใช้การสร้างข้อความด้วยโมเดล GPT และ Bloom บน Amazon SageMaker JumpStart

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

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

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

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

ภาพรวม 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

การสร้างข้อความ, GPT-2 และ Bloom

การสร้างข้อความคืองานสร้างข้อความที่มีความคล่องแคล่วและดูแยกไม่ออกจากข้อความที่เขียนโดยมนุษย์ เป็นที่รู้จักกันว่า การสร้างภาษาธรรมชาติ.

GPT-2 เป็นโมเดลการสร้างข้อความที่ใช้ตัวแปลงสัญญาณยอดนิยม ได้รับการฝึกอบรมล่วงหน้าในคลังข้อความดิบภาษาอังกฤษขนาดใหญ่โดยไม่มีการติดฉลากโดยมนุษย์ มันได้รับการฝึกฝนเกี่ยวกับงานที่ได้รับลำดับบางส่วน (ประโยคหรือส่วนของข้อความ) โมเดลจำเป็นต้องทำนายคำหรือโทเค็นถัดไปในลำดับ

Bloom ยังเป็นโมเดลการสร้างข้อความที่ใช้ Transformer และได้รับการฝึกฝนคล้ายกับ GPT-2 อย่างไรก็ตาม Bloom ได้รับการฝึกอบรมล่วงหน้าในภาษาต่างๆ 46 ภาษาและภาษาโปรแกรม 13 ภาษา ต่อไปนี้เป็นตัวอย่างของการเรียกใช้การสร้างข้อความด้วยโมเดล Bloom:

Input: "Some people like dogs, some people like cats"
Output: "Some people like dogs, some people like cats some people like birds, some people like fish,"

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

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

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

เข้าถึง JumpStart ผ่าน Studio UI และรันการอนุมานด้วยโมเดลที่ผ่านการฝึกอบรมมาแล้ว

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

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

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

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

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

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

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

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

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

model_id, model_version = "huggingface-textgeneration-bloom-560m", "*"

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

Bloom เป็นโมเดลขนาดใหญ่มากและอาจใช้เวลาถึง 20-25 นาทีในการปรับใช้ คุณยังสามารถใช้โมเดลที่เล็กกว่า เช่น GPT-2 หากต้องการใช้งานโมเดล GPT-2 ที่ฝึกไว้ล่วงหน้า คุณสามารถตั้งค่าได้ model_id = huggingface-textgeneration-gpt2. สำหรับรายการรุ่นอื่นๆ ที่มีใน JumpStart โปรดดูที่ ตารางรุ่นที่มีจำหน่ายของ JumpStart.

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

หลังจากปรับใช้แบบจำลองของเราแล้ว เราสามารถรับการคาดการณ์จากแบบจำลองได้แบบเรียลไทม์!

เรียกใช้การอนุมาน

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

def query(model_predictor, text):
    """Query the model predictor."""

    encoded_text = json.dumps(text).encode("utf-8")

    query_response = model_predictor.predict(
        encoded_text,
        {
            "ContentType": "application/x-text",
            "Accept": "application/json",
        },
    )
    return query_response

การตอบสนองปลายทางคือวัตถุ JSON ที่มีข้อความป้อนตามด้วยข้อความที่สร้างขึ้น:

def parse_response(query_response):
    """Parse response and return the generated text."""

    model_predictions = json.loads(query_response)
    generated_text = model_predictions["generated_text"]
    return generated_text
    
text = "Some people like dogs, some people like cats"
query_response = query(model_predictor, text)
parse_response(query_response)

ผลลัพธ์ของเรามีดังนี้:

"Some people like dogs, some people like cats some people like birds, some people like fish,"

สรุป

ในโพสต์นี้ เราได้แสดงวิธีปรับใช้โมเดลการสร้างข้อความที่ผ่านการฝึกอบรมล่วงหน้าโดยใช้ 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, บิ๊กดาต้า และการพัฒนาซอฟต์แวร์

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