ปรับแต่งโค้ด Llama บน Amazon SageMaker JumpStart | อเมซอนเว็บเซอร์วิส

วันนี้เรารู้สึกตื่นเต้นที่จะประกาศความสามารถในการปรับแต่งโมเดล Code Llama โดยใช้ Meta Amazon SageMaker JumpStart. กลุ่ม Code Llama ของโมเดลภาษาขนาดใหญ่ (LLM) คือคอลเลกชันของโมเดลการสร้างโค้ดที่ได้รับการฝึกอบรมล่วงหน้าและปรับแต่งอย่างละเอียด โดยมีขนาดตั้งแต่ 7 พันล้านถึง 70 พันล้านพารามิเตอร์ โมเดล Code Llama ที่ได้รับการปรับแต่งอย่างละเอียดจะให้ความแม่นยำและความสามารถในการอธิบายที่ดีกว่าโมเดล Code Llama พื้นฐาน ดังที่เห็นได้จากการทดสอบกับ มนุษย์อีวาล และชุดข้อมูล MBPP คุณสามารถปรับแต่งและปรับใช้โมเดล Code Llama ด้วย SageMaker JumpStart ได้โดยใช้ สตูดิโอ Amazon SageMaker UI เพียงไม่กี่คลิกหรือใช้ SageMaker Python SDK การปรับแต่งโมเดลลามะอย่างละเอียดนั้นขึ้นอยู่กับสคริปต์ที่ให้ไว้ใน repo ของ llama-repo GitHub จาก Meta โดยใช้เทคนิคการหาปริมาณ PyTorch FSDP, PEFT/LoRA และ Int8

ในโพสต์นี้ เราจะอธิบายวิธีปรับแต่งโมเดลที่ได้รับการฝึกล่วงหน้าของ Code Llama ผ่าน SageMaker JumpStart ผ่านประสบการณ์ UI และ SDK แบบคลิกเดียวที่มีให้ใช้งานต่อไปนี้ พื้นที่เก็บข้อมูล GitHub.

SageMaker JumpStart คืออะไร

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

รหัสลามะคืออะไร

Code Llama เป็นเวอร์ชันเฉพาะของโค้ด ลามะ 2 ที่สร้างขึ้นโดยการฝึกอบรม Llama 2 เพิ่มเติมเกี่ยวกับชุดข้อมูลเฉพาะโค้ดและสุ่มตัวอย่างข้อมูลจากชุดข้อมูลเดียวกันนั้นให้นานขึ้น Code Llama มีความสามารถในการเขียนโค้ดที่ได้รับการปรับปรุง สามารถสร้างโค้ดและภาษาธรรมชาติเกี่ยวกับโค้ดได้จากทั้งโค้ดและภาษาธรรมชาติพร้อมท์ (เช่น "เขียนฟังก์ชันที่ส่งออกลำดับฟีโบนักชีให้ฉัน") คุณยังสามารถใช้มันเพื่อเติมโค้ดให้สมบูรณ์และแก้ไขจุดบกพร่องได้ รองรับภาษาการเขียนโปรแกรมยอดนิยมมากมายที่ใช้ในปัจจุบัน รวมถึง Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash และอื่นๆ

ทำไมต้องปรับแต่งโมเดล Code Llama

Meta เผยแพร่เกณฑ์มาตรฐานประสิทธิภาพของ Code Llama HumanEval และ MBPP สำหรับภาษาการเขียนโค้ดทั่วไป เช่น Python, Java และ JavaScript ประสิทธิภาพของโมเดล Code Llama Python บน HumanEval แสดงให้เห็นถึงประสิทธิภาพที่แตกต่างกันในภาษาการเขียนโค้ดและงานต่างๆ ตั้งแต่ 38% ในรุ่น 7B Python ถึง 57% ในรุ่น 70B Python นอกจากนี้ โมเดล Code Llama ที่ได้รับการปรับแต่งอย่างละเอียดในภาษาการเขียนโปรแกรม SQL ยังแสดงผลลัพธ์ที่ดีกว่า ดังที่เห็นได้จากการวัดประสิทธิภาพการประเมิน SQL เกณฑ์มาตรฐานที่เผยแพร่เหล่านี้เน้นย้ำถึงคุณประโยชน์ที่เป็นไปได้ของการปรับแต่งโมเดล Code Llama อย่างละเอียด ช่วยให้เกิดประสิทธิภาพ การปรับแต่ง และการปรับให้เข้ากับโดเมนและงานการเขียนโค้ดเฉพาะได้ดียิ่งขึ้น

การปรับแต่งแบบละเอียดโดยไม่ต้องใช้โค้ดผ่าน SageMaker Studio UI

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

1. บนคอนโซล SageMaker Studio เลือก เริ่มกระโดด ในบานหน้าต่างนำทาง

คุณจะพบรายชื่อโมเดลมากกว่า 350 รุ่น ตั้งแต่รุ่นโอเพ่นซอร์สและรุ่นที่เป็นกรรมสิทธิ์

2. ค้นหาโมเดล Code Llama
   

หากคุณไม่เห็นโมเดล Code Llama คุณสามารถอัปเดตเวอร์ชัน SageMaker Studio ได้โดยการปิดระบบแล้วรีสตาร์ท สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการอัพเดตเวอร์ชัน โปรดดูที่ ปิดและอัปเดตแอป Studio. คุณยังสามารถค้นหารุ่นย่อยอื่นๆ ได้โดยเลือก สำรวจโมเดลการสร้างโค้ดทั้งหมด หรือค้นหา Code Llama ในช่องค้นหา

ปัจจุบัน SageMaker JumpStart รองรับการปรับแต่งคำสั่งอย่างละเอียดสำหรับโมเดล Code Llama ภาพหน้าจอต่อไปนี้แสดงหน้าการปรับแต่งอย่างละเอียดสำหรับรุ่น Code Llama 2 70B

3. สำหรับ ตำแหน่งชุดข้อมูลการฝึกอบรมคุณสามารถชี้ไปที่ บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon บัคเก็ต (Amazon S3) ที่ประกอบด้วยชุดข้อมูลการฝึกอบรมและการตรวจสอบเพื่อการปรับแต่งอย่างละเอียด
4. ตั้งค่าคอนฟิกูเรชันการปรับใช้ ไฮเปอร์พารามิเตอร์ และการตั้งค่าความปลอดภัยสำหรับการปรับแต่งอย่างละเอียด
5. Choose รถไฟ เพื่อเริ่มงานปรับแต่งอย่างละเอียดบนอินสแตนซ์ SageMaker ML
   

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

6. หลังจากปรับแต่งโมเดลอย่างละเอียดแล้ว คุณสามารถปรับใช้ได้โดยใช้หน้าโมเดลบน SageMaker JumpStart

ตัวเลือกในการปรับใช้แบบจำลองที่ปรับแต่งอย่างละเอียดจะปรากฏขึ้นเมื่อการปรับแต่งแบบละเอียดเสร็จสิ้น ดังที่แสดงในภาพหน้าจอต่อไปนี้

ปรับแต่งอย่างละเอียดผ่าน SageMaker Python SDK

ในส่วนนี้ เราจะสาธิตวิธีปรับแต่งโมเดล Code LIama โดยใช้ SageMaker Python SDK บนชุดข้อมูลที่มีรูปแบบคำสั่ง โดยเฉพาะอย่างยิ่ง โมเดลนี้ได้รับการปรับแต่งอย่างละเอียดสำหรับชุดงานการประมวลผลภาษาธรรมชาติ (NLP) ที่อธิบายโดยใช้คำแนะนำ ซึ่งจะช่วยปรับปรุงประสิทธิภาพของโมเดลสำหรับงานที่มองไม่เห็นด้วยการแจ้งเตือนแบบ Zero-Shot

ทำตามขั้นตอนต่อไปนี้เพื่อเสร็จสิ้นงานปรับแต่งของคุณ คุณสามารถรับโค้ดการปรับแต่งทั้งหมดได้จาก พื้นที่เก็บข้อมูล GitHub.

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

{
	'system_prompt': 'a chat',
	'question': 'Please focus on the efficiency of this problem and provide code in python:nYou are given two strings `s` and `t` consisting of only lowercase English letters.nnReturn _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `s`.nnA **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.nn**Example 1:**nn**Input:** s = "coaching ", t = "coding "n**Output:** 4n**Explanation:** Append the characters "ding " to the end of s so that s = "coachingding ".nNow, t is a subsequence of s ( "**co**aching**ding** ").nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.nn**Example 2:**nn**Input:** s = "abcde ", t = "a "n**Output:** 0n**Explanation:** t is already a subsequence of s ( "**a**bcde ").nn**Example 3:**nn**Input:** s = "z ", t = "abcde "n**Output:** 5n**Explanation:** Append the characters "abcde " to the end of s so that s = "zabcde ".nNow, t is a subsequence of s ( "z**abcde** ").nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.nn**Constraints:**nn* `1 <= s.length, t.length <= 105`n* `s` and `t` consist only of lowercase English letters.',
	'response': '### Explanationn The algorithm maintains two pointers, `i` and `j`, to iterate through the given strings `s` and `t`. The pointer `i` iterates through the string `s` and the pointer `j` iterates through the string `t`. While iterating through `s`, if we find a character that matches the current character in `t`, we increment the `j` pointer. This is because the matched character can be a part of the subsequence we are looking for. The iteration stops when either `i` reaches the end of `s` or `j` reaches the end of `t`.nnAt the end, we subtract the index `j` from the length of `t`. This gives us the minimum number of characters that need to be appended to the end of `s` so that `t` becomes a subsequence of `s`.nn### Pseudocode:n```nMIN-ADDITION(s, t)n s_len = LENGTH(s)n t_len = LENGTH(t)n i = 1n j = 1n WHILE i <= s_len AND j <= t_lenn IF s[i] == t[j]n j = j + 1n ENDIFn i = i + 1n ENDWHILEn RETURN t_len - j + 1nENDMIN-ADDITIONn```nn### Coden```pythonndef min_addition(s: str, t: str) -> int:n s_len = len(s)n t_len = len(t)n i, j = 0, 0n while i < s_len and j < t_len:n if s[i] == t[j]:n j += 1n i += 1n return t_len - jn```n'
}

โฟลเดอร์การฝึกอบรมสามารถมีไฟล์ template.json ไฟล์อธิบายรูปแบบอินพุตและเอาต์พุต ต่อไปนี้เป็นตัวอย่างเทมเพลต:

{
    "prompt": "{system_prompt} ### Input: {question}",
    "completion": "{response}"
}

เพื่อให้ตรงกับเทมเพลต แต่ละตัวอย่างในไฟล์บรรทัด JSON จะต้องรวมไว้ด้วย system_prompt, questionและ response สาขา ในการสาธิตนี้เราใช้ ชุดข้อมูล Dolphin Coder จากเรื่อง กอดหน้า.

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

from sagemaker.jumpstart.estimator import JumpStartEstimator

model_id = "meta-textgeneration-llama-codellama-7b" 
model_version = "*"
train_data_location = f"s3://{your_own_bucket_hosting_training_data}/" # training data in s3 bucket

estimator = JumpStartEstimator(
    model_id=model_id,
    model_version=model_version,
    hyperparameters= hyperparameters,
    environment={
        "accept_eula": "false"
    },  # please change `accept_eula` to be `true` to accept EULA.
)

estimator.fit({"training": train_data_location})

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

finetuned_predictor = estimator.deploy()

เทคนิคการปรับแต่งอย่างละเอียด

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

• การปรับตัวระดับต่ำ (LoRA) – นี่คือการปรับพารามิเตอร์แบบละเอียดที่มีประสิทธิภาพ (PEFT) ประเภทหนึ่งสำหรับการปรับแบบละเอียดอย่างมีประสิทธิภาพสำหรับรุ่นขนาดใหญ่ ด้วยวิธีนี้ คุณจะหยุดทั้งโมเดลและเพิ่มพารามิเตอร์หรือเลเยอร์ที่ปรับได้ชุดเล็กๆ ลงในโมเดลเท่านั้น ตัวอย่างเช่น แทนที่จะฝึกพารามิเตอร์ทั้งหมด 7 พันล้านพารามิเตอร์สำหรับ Llama 2 7B คุณสามารถปรับแต่งพารามิเตอร์ได้น้อยกว่า 1% ซึ่งจะช่วยลดความต้องการหน่วยความจำได้อย่างมาก เนื่องจากคุณจำเป็นต้องจัดเก็บการไล่ระดับสี สถานะเครื่องมือเพิ่มประสิทธิภาพ และข้อมูลอื่นๆ ที่เกี่ยวข้องกับการฝึกอบรมเพียง 1% ของพารามิเตอร์เท่านั้น นอกจากนี้ยังช่วยลดเวลาการฝึกอบรมและค่าใช้จ่ายอีกด้วย สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับวิธีการนี้ โปรดดูที่ LoRA: การปรับตัวในระดับต่ำของโมเดลภาษาขนาดใหญ่.
• การหาปริมาณ Int8 – แม้จะมีการปรับปรุงประสิทธิภาพ เช่น LoRA แต่โมเดลอย่าง Llama 70B ก็ยังใหญ่เกินกว่าจะฝึกได้ หากต้องการลดขนาดหน่วยความจำระหว่างการฝึก คุณสามารถใช้การวัดปริมาณ Int8 ในระหว่างการฝึกได้ โดยทั่วไปการหาปริมาณจะลดความแม่นยำของประเภทข้อมูลจุดลอยตัว แม้ว่าการทำเช่นนี้จะลดหน่วยความจำที่จำเป็นในการจัดเก็บน้ำหนักโมเดล แต่ประสิทธิภาพก็ลดลงเนื่องจากข้อมูลสูญหาย การหาปริมาณ Int8 ใช้ความแม่นยำเพียงหนึ่งในสี่เท่านั้น แต่ไม่ได้ทำให้ประสิทธิภาพลดลง เนื่องจากไม่ได้ทำให้บิตลดลง มันจะปัดเศษข้อมูลจากประเภทหนึ่งไปอีกประเภทหนึ่ง หากต้องการเรียนรู้เกี่ยวกับการหาปริมาณ Int8 โปรดดูที่ LLM.int8(): การคูณเมทริกซ์ 8 บิตสำหรับ Transformers ตามขนาด.
• ข้อมูลแบบขนานที่แบ่งใช้อย่างสมบูรณ์ (FSDP) – นี่คืออัลกอริธึมการฝึกอบรมข้อมูลแบบคู่ขนานประเภทหนึ่งที่แบ่งพารามิเตอร์ของโมเดลให้กับผู้ปฏิบัติงานแบบขนานข้อมูล และสามารถเลือกถ่ายส่วนหนึ่งของการคำนวณการฝึกอบรมไปยัง CPU ได้ แม้ว่าพารามิเตอร์จะถูกแบ่งส่วนใน GPU ที่แตกต่างกัน แต่การคำนวณของไมโครแบทช์แต่ละรายการจะอยู่ในเครื่องของผู้ปฏิบัติงาน GPU โดยแบ่งส่วนพารามิเตอร์ให้มีความสม่ำเสมอมากขึ้น และบรรลุประสิทธิภาพที่ได้รับการปรับปรุงให้เหมาะสมผ่านการสื่อสารและการคำนวณที่ทับซ้อนกันระหว่างการฝึก

ตารางต่อไปนี้สรุปรายละเอียดของแต่ละรุ่นพร้อมการตั้งค่าที่แตกต่างกัน

การปรับแต่งโมเดล Llama อย่างละเอียดจะขึ้นอยู่กับสคริปต์ที่จัดเตรียมไว้ดังต่อไปนี้ repo GitHub.

ไฮเปอร์พารามิเตอร์ที่รองรับสำหรับการฝึก

การปรับแต่ง Code Llama 2 อย่างละเอียดรองรับไฮเปอร์พารามิเตอร์จำนวนหนึ่ง ซึ่งแต่ละพารามิเตอร์สามารถส่งผลต่อความต้องการหน่วยความจำ ความเร็วในการฝึกฝน และประสิทธิภาพของโมเดลที่ได้รับการปรับแต่ง:

• ยุค – จำนวนรอบที่อัลกอริธึมการปรับแต่งแบบละเอียดใช้ผ่านชุดข้อมูลการฝึก ต้องเป็นจำนวนเต็มที่มากกว่า 1 ค่าเริ่มต้นคือ 5
• อัตราการเรียนรู้ – อัตราการอัปเดตน้ำหนักแบบจำลองหลังจากทำงานผ่านตัวอย่างการฝึกอบรมแต่ละชุด จะต้องมีค่าทศนิยมเป็นบวกมากกว่า 0 ค่าเริ่มต้นคือ 1e-4
• Instruction_tuned – ไม่ว่าจะสั่งสอน-เทรนโมเดลหรือไม่ก็ตาม จะต้องเป็น True or False. ค่าเริ่มต้นคือ False.
• ต่อ_อุปกรณ์_train_batch_size – ขนาดแบตช์ต่อคอร์ GPU/CPU สำหรับการฝึก ต้องเป็นจำนวนเต็มบวก ค่าเริ่มต้นคือ 4
• ต่อ_อุปกรณ์_eval_batch_size – ขนาดแบตช์ต่อคอร์ GPU/CPU สำหรับการประเมิน ต้องเป็นจำนวนเต็มบวก ค่าเริ่มต้นคือ 1
• max_train_samples – เพื่อวัตถุประสงค์ในการแก้ไขจุดบกพร่องหรือการฝึกที่รวดเร็วขึ้น ให้ตัดจำนวนตัวอย่างการฝึกให้เหลือเพียงค่านี้ ค่า -1 หมายถึง การใช้ตัวอย่างการฝึกทั้งหมด ต้องเป็นจำนวนเต็มบวกหรือ -1 ค่าเริ่มต้นคือ -1
• max_val_samples – เพื่อวัตถุประสงค์ในการแก้ไขจุดบกพร่องหรือการฝึกอบรมที่รวดเร็วยิ่งขึ้น ให้ตัดจำนวนตัวอย่างการตรวจสอบความถูกต้องให้เหลือเพียงค่านี้ ค่า -1 หมายถึงการใช้ตัวอย่างการตรวจสอบความถูกต้องทั้งหมด ต้องเป็นจำนวนเต็มบวกหรือ -1 ค่าเริ่มต้นคือ -1
• max_input_length – ความยาวลำดับอินพุตทั้งหมดสูงสุดหลังโทเค็น ลำดับที่นานกว่านี้จะถูกตัดทอน ถ้า -1, max_input_length ถูกตั้งค่าเป็นขั้นต่ำ 1024 และความยาวโมเดลสูงสุดที่กำหนดโดยโทเค็นไนเซอร์ หากตั้งค่าเป็นค่าบวก max_input_length ถูกตั้งค่าเป็นขั้นต่ำของค่าที่ให้ไว้และ model_max_length กำหนดโดยโทเค็นไนเซอร์ ต้องเป็นจำนวนเต็มบวกหรือ -1 ค่าเริ่มต้นคือ -1
• validation_split_ratio – หากช่องทางการตรวจสอบเป็น noneอัตราส่วนของการแยกการตรวจสอบความถูกต้องของรถไฟจากข้อมูลรถไฟจะต้องอยู่ระหว่าง 0–1 ค่าเริ่มต้นคือ 0.2
• train_data_split_seed – หากไม่มีข้อมูลการตรวจสอบความถูกต้อง การดำเนินการนี้จะแก้ไขการแยกข้อมูลการฝึกอบรมอินพุตแบบสุ่มไปยังข้อมูลการฝึกอบรมและการตรวจสอบความถูกต้องที่ใช้โดยอัลกอริทึม ต้องเป็นจำนวนเต็ม ค่าเริ่มต้นคือ 0
• preprocessing_num_workers – จำนวนกระบวนการที่จะใช้สำหรับการประมวลผลล่วงหน้า ถ้า Noneกระบวนการหลักใช้สำหรับการประมวลผลล่วงหน้า ค่าเริ่มต้นคือ None.
• ลอร่า_อาร์ – Lora R. ต้องเป็นจำนวนเต็มบวก ค่าเริ่มต้นคือ 8
• ลอรา_อัลฟา – ลอร่า อัลฟ่า ต้องเป็นจำนวนเต็มบวก ค่าเริ่มต้นคือ 32
• lora_dropout – ลอรา ดรอปเอาท์ จะต้องมีค่าทศนิยมเป็นบวกระหว่าง 0 ถึง 1 ค่าเริ่มต้นคือ 0.05
• int8_quantization - ถ้า Trueโมเดลนี้โหลดด้วยความแม่นยำ 8 บิตสำหรับการฝึก ค่าเริ่มต้นสำหรับ 7B และ 13B คือ False. ค่าเริ่มต้นสำหรับ 70B คือ True.
• Enable_fsdp – หากเป็นจริง การฝึกอบรมจะใช้ FSDP ค่าเริ่มต้นสำหรับ 7B และ 13B เป็นจริง ค่าเริ่มต้นสำหรับ 70B เป็นเท็จ โปรดทราบว่า int8_quantization ไม่รองรับ FSDP

เมื่อเลือกไฮเปอร์พารามิเตอร์ ให้พิจารณาสิ่งต่อไปนี้:

• การตั้งค่า int8_quantization=True ลดความต้องการความจำและนำไปสู่การฝึกที่เร็วขึ้น
• ลดลง per_device_train_batch_size และ max_input_length ลดความต้องการหน่วยความจำและสามารถเรียกใช้บนอินสแตนซ์ขนาดเล็กได้ อย่างไรก็ตาม การตั้งค่าที่ต่ำมากอาจเพิ่มเวลาการฝึก
• หากคุณไม่ได้ใช้การหาปริมาณ Int8 (int8_quantization=False) ใช้ FSDP (enable_fsdp=True) เพื่อการฝึกอบรมที่รวดเร็วและมีประสิทธิภาพ

ประเภทอินสแตนซ์ที่รองรับสำหรับการฝึกอบรม

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

เมื่อเลือกประเภทอินสแตนซ์ ให้พิจารณาสิ่งต่อไปนี้:

• อินสแตนซ์ G5 ให้การฝึกอบรมที่มีประสิทธิภาพมากที่สุดในบรรดาประเภทอินสแตนซ์ที่รองรับ ดังนั้น หากคุณมีอินสแตนซ์ G5 คุณก็ควรใช้อินสแตนซ์เหล่านั้น
• เวลาการฝึกอบรมส่วนใหญ่ขึ้นอยู่กับจำนวน GPU และหน่วยความจำ CUDA ที่พร้อมใช้งาน ดังนั้น การฝึกบนอินสแตนซ์ที่มี GPU จำนวนเท่ากัน (เช่น ml.g5.2xlarge และ ml.g5.4xlarge) จึงใกล้เคียงกันโดยประมาณ ดังนั้น คุณสามารถใช้อินสแตนซ์ที่ถูกกว่าสำหรับการฝึกได้ (ml.g5.2xlarge)
• เมื่อใช้อินสแตนซ์ p3 การฝึกจะดำเนินการด้วยความแม่นยำ 32 บิต เนื่องจากอินสแตนซ์เหล่านี้ไม่รองรับ bfloat16 ดังนั้น งานการฝึกจะใช้จำนวนหน่วยความจำ CUDA เป็นสองเท่าเมื่อฝึกบนอินสแตนซ์ p3 เมื่อเทียบกับอินสแตนซ์ g5

หากต้องการเรียนรู้เกี่ยวกับค่าใช้จ่ายในการฝึกอบรมต่ออินสแตนซ์ โปรดดูที่ Amazon EC2 G5 อินสแตนซ์.

การประเมินผล

การประเมินเป็นขั้นตอนสำคัญในการประเมินประสิทธิภาพของแบบจำลองที่ได้รับการปรับแต่งอย่างละเอียด เรานำเสนอการประเมินทั้งเชิงคุณภาพและเชิงปริมาณเพื่อแสดงการปรับปรุงแบบจำลองที่ได้รับการปรับแต่งมากกว่าแบบจำลองที่ไม่ได้ปรับแต่ง ในการประเมินเชิงคุณภาพ เราจะแสดงตัวอย่างการตอบสนองจากทั้งแบบจำลองที่ได้รับการปรับแต่งและไม่ได้รับการปรับแต่ง ในการประเมินเชิงปริมาณเราใช้ มนุษย์อีวาลซึ่งเป็นชุดทดสอบที่พัฒนาโดย OpenAI เพื่อสร้างโค้ด Python เพื่อทดสอบความสามารถในการสร้างผลลัพธ์ที่ถูกต้องและแม่นยำ พื้นที่เก็บข้อมูล HumanEval อยู่ภายใต้ใบอนุญาตของ MIT เราปรับแต่งตัวแปร Python ของโมเดล Code LIama ทั้งหมดในขนาดที่แตกต่างกัน (Code LIama Python 7B, 13B, 34B และ 70B บน ชุดข้อมูล Dolphin Coder) และนำเสนอผลการประเมินในส่วนต่อไปนี้

การประเมินเชิงคุณภาพ

เมื่อปรับใช้โมเดลที่ได้รับการปรับแต่งแล้ว คุณสามารถเริ่มใช้ตำแหน่งข้อมูลเพื่อสร้างโค้ดได้ ในตัวอย่างต่อไปนี้ เรานำเสนอการตอบสนองจากทั้งตัวแปรพื้นฐานและโค้ด LIama 34B Python ที่ปรับแต่งอย่างละเอียดในตัวอย่างทดสอบใน ชุดข้อมูล Dolphin Coder:

alpaca_format = """{system_prompt}

### Input:
{question}

### Response:n"""

system="You are a coding AI"
prompt = """Please explain the reasoning behind the following solution and 
provide code in python: Given a string `s`, return the longest palindromic 
substring in `s`. **Example 1:** **Input:** s = "babad " **Output:** "bab " 
**Explanation:** "aba " is also a valid answer. **Example 2:** 
**Input:** s = "cbbd " **Output:** "bb " 
**Constraints:** * `1 <= s.length <= 1000` * `s` consist of only digits 
and English letters."""

payload = json.dumps({
    "inputText": alpaca_format.format(system_prompt=system, question=prompt),
    "textGenerationConfig": {
    "maxTokenCount": 2048,
    "temperature":0.2
}})

finetuned_response = finetuned_predictor.predict(payload)
finetuned_response["generated_text"]

โมเดล Code Llama ที่ได้รับการปรับแต่งอย่างละเอียด นอกเหนือจากการให้โค้ดสำหรับการสืบค้นก่อนหน้าแล้ว ยังสร้างคำอธิบายโดยละเอียดของวิธีการและโค้ดเทียมอีกด้วย

รหัส Llama 34b Python การตอบสนองแบบไม่ปรับแต่ง:

### Code
def longestPalindrome(s):
    # Fill this in.
    longest = ""
    for i in range(len(s)):
        for j in range(len(s), i, -1):
            if len(longest) >= j-i:
                break
            elif s[i:j] == s[i:j][::-1]:
                longest = s[i:j]
                break
    return longest

print(longestPalindrome("abaxyzzyxf"))
# axyzzyx
###Reference:
- [https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/]
(https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/)

Code Llama 34B Python การตอบสนองแบบละเอียด

### Explanation
The algorithm uses dynamic programming to find the longest palindromic substring. 
It initializes a 2D boolean table `dp` with the same dimensions as the input string `s`. 
The `dp[i][j]` value is set to `true` if the substring from index `i` to index `j` is a palindrome.

The algorithm then iterates through the string in a nested loop, starting from the first character to the last. 
It checks if the substring from index `i` to index `j` is a palindrome. 
If it is, it sets the `dp[i][j]` value to `true`. 
If the substring is of length 2 or 3, it sets the `dp[i][j]` value to `true` as well.

After the nested loop, the algorithm iterates through the `dp` table to find the longest palindromic substring. 
It keeps track of the maximum length and the starting and ending indices of the substring.

Finally, the algorithm returns the substring from the starting index to the ending index.

### Code
```python
def longestPalindrome(s: str) -> str:
    n = len(s)
    dp = [[False] * n for _ in range(n)]

    for i in range(n):
        dp[i][i] = True
        if i + 1 < n:
            dp[i][i + 1] = s[i] == s[i + 1]

    max_len = 1
    start = 0
    end = 0

    for i in range(n - 1):
        for j in range(i + 1, n):
            if j - i == 1 or dp[i + 1][j - 1]:
                dp[i][j] = s[i] == s[j]
                if j - i + 1 > max_len:
                    max_len = j - i + 1
                    start = i
                    end = j

    return s[start:end + 1]
```

ความจริงพื้นดิน

### Explanation 
1. Initialize `start` and `maxLength` for result substring. 
2. Iterate through the given string `s` using the index `i`. 
3. For each index `i`, create two pointers `l` and `r` starting at `i`. 
4. Check if there's a consecutive sequence of identical characters, increment the right pointer `r` until the end of the sequence is reached. 
5. Update the index `i` to the current value of `r`. 
6. Expand the pointers `l` and `r` outwards to find the longest palindromic substring, checking that characters on both sides are equal. 
7. If the current length of the substring is greater than `maxLength`, update `start` and `maxLength`. 
8. Return the longest palindromic substring using the `start` and `maxLength`. 

### Code 
```python 
def longest_palindromic_substring(s: str) → str:
    n = len(s)
    if n == 0:
        return ""
    
    start, max_length = 0, 1
    for i in range(n):
        l, r = i, i
        while r < n - 1 and s[r] == s[r + 1]:
            r += 1
            i = r
        while l > 0 and r < n - 1 and s[l - 1] == s[r + 1]:
            l -= 1
            r += 1
        length = r - l + 1
        if length > max_length:
            start, max_length = l, length
    return s[start:start + max_length]
```

สิ่งที่น่าสนใจคือ Code Llama 34B Python เวอร์ชันที่ได้รับการปรับแต่งอย่างละเอียดของเรามอบโซลูชันตามการเขียนโปรแกรมแบบไดนามิกให้กับสตริงย่อย Palindromic ที่ยาวที่สุด ซึ่งแตกต่างจากโซลูชันที่ให้ไว้ในความจริงภาคพื้นดินจากตัวอย่างการทดสอบที่เลือก เหตุผลด้านโมเดลที่ได้รับการปรับแต่งอย่างละเอียดของเราและอธิบายโซลูชันตามการเขียนโปรแกรมแบบไดนามิกโดยละเอียด ในทางกลับกัน โมเดลที่ไม่ได้ปรับแต่งอย่างละเอียดจะทำให้เกิดภาพหลอนที่อาจเกิดขึ้นทันทีหลังจาก print คำสั่ง (แสดงในเซลล์ด้านซ้าย) เนื่องจากการส่งออก axyzzyx ไม่ใช่พาลินโดรมที่ยาวที่สุดในสตริงที่กำหนด ในแง่ของความซับซ้อนของเวลา โดยทั่วไปแล้วโซลูชันการเขียนโปรแกรมแบบไดนามิกจะดีกว่าแนวทางเริ่มแรก โซลูชันการเขียนโปรแกรมแบบไดนามิกมีความซับซ้อนของเวลาเป็น O(n^2) โดยที่ n คือความยาวของสตริงอินพุต วิธีนี้จะมีประสิทธิภาพมากกว่าโซลูชันเริ่มต้นจากโมเดลที่ไม่ได้ปรับแต่งอย่างละเอียด ซึ่งมีความซับซ้อนด้านเวลากำลังสองเท่ากับ O(n^2) แต่มีแนวทางที่ได้รับการปรับปรุงให้เหมาะสมน้อยกว่า

นี่ดูมีแนวโน้ม! โปรดจำไว้ว่า เราปรับแต่งตัวแปร Code LIama Python อย่างละเอียดเพียง 10% ของ ชุดข้อมูล Dolphin Coder. มีอะไรอีกมากมายให้สำรวจ!

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

การประเมินเชิงปริมาณด้วย HumanEval

HumanEval เป็นชุดประเมินผลสำหรับการประเมินความสามารถในการแก้ปัญหาของ LLM เกี่ยวกับปัญหาการเขียนโค้ดแบบ Python ดังที่อธิบายไว้ในรายงาน การประเมินโมเดลภาษาขนาดใหญ่ที่ได้รับการฝึกอบรมเกี่ยวกับโค้ด. โดยเฉพาะอย่างยิ่ง ประกอบด้วยปัญหาการเขียนโปรแกรมที่ใช้ Python ดั้งเดิม 164 ปัญหา ซึ่งประเมินความสามารถของโมเดลภาษาในการสร้างโค้ดตามข้อมูลที่ให้ไว้ เช่น ลายเซ็นฟังก์ชัน สตริงเอกสาร เนื้อหา และการทดสอบหน่วย

สำหรับคำถามเกี่ยวกับการเขียนโปรแกรมแบบ Python แต่ละคำถาม เราจะส่งคำถามไปยังโมเดล Code LIama ที่ใช้งานบนตำแหน่งข้อมูล SageMaker เพื่อรับคำตอบ k ต่อไป เราจะรันการตอบสนอง k แต่ละรายการในการทดสอบการรวมในพื้นที่เก็บข้อมูล HumanEval หากการตอบสนองใดๆ ของการตอบสนอง k ผ่านการทดสอบการรวม เราจะถือว่ากรณีทดสอบนั้นสำเร็จ ไม่อย่างนั้นก็ล้มเหลว จากนั้นเราทำซ้ำขั้นตอนเพื่อคำนวณอัตราส่วนของกรณีที่ประสบความสำเร็จตามชื่อคะแนนการประเมินขั้นสุดท้าย pass@k. ตามแนวทางปฏิบัติมาตรฐาน เราตั้งค่า k เป็น 1 ในการประเมินของเรา เพื่อสร้างคำตอบเดียวต่อคำถามเท่านั้น และทดสอบว่าผ่านการทดสอบบูรณาการหรือไม่

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

%pip3 install human_eval
import json
from human_eval.evaluation import evaluate_functional_correctness
from human_eval.data import write_jsonl, read_problems
from tqdm import tqdm
problems = read_problems()

num_samples_per_task = 1 # value k: number of responses for each question
samples = [
    dict(task_id=task_id, completion=generate_one_completion(problems[task_id]["prompt"]))
    for task_id in tqdm(problems)
    for _ in range(num_samples_per_task)
]
write_jsonl("samples.jsonl", samples)

evaluate_functional_correctness('./samples.jsonl')

ตารางต่อไปนี้แสดงการปรับปรุงโมเดล Code LIama Python ที่ได้รับการปรับแต่งอย่างละเอียด เทียบกับโมเดลที่ไม่ได้ปรับแต่งอย่างละเอียดในขนาดโมเดลต่างๆ เพื่อให้มั่นใจถึงความถูกต้อง เรายังปรับใช้โมเดล Code LIama ที่ไม่ได้รับการปรับแต่งในจุดสิ้นสุด SageMaker และดำเนินการผ่านการประเมิน Human Eval ที่ พาส@1 ตัวเลข (แถวแรกในตารางต่อไปนี้) ตรงกับตัวเลขที่รายงานใน เอกสารวิจัยรหัสลามะ พารามิเตอร์การอนุมานได้รับการตั้งค่าอย่างสม่ำเสมอเป็น "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

ดังที่เราเห็นจากผลลัพธ์ ตัวแปร Code LIama Python ที่ได้รับการปรับแต่งอย่างละเอียดทั้งหมดแสดงการปรับปรุงที่สำคัญกว่าโมเดลที่ไม่ได้ปรับแต่งอย่างละเอียด โดยเฉพาะอย่างยิ่ง Code LIama Python 70B มีประสิทธิภาพเหนือกว่าโมเดลที่ไม่ได้ปรับแต่งประมาณ 12%

ตอนนี้คุณสามารถลองปรับแต่งโมเดล Code LIama บนชุดข้อมูลของคุณเองได้แล้ว

ทำความสะอาด

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

สรุป

ในโพสต์นี้ เราได้พูดคุยถึงการปรับแต่งโมเดล Code Llama 2 ของ Meta อย่างละเอียดโดยใช้ SageMaker JumpStart เราแสดงให้เห็นว่าคุณสามารถใช้คอนโซล SageMaker JumpStart ใน SageMaker Studio หรือ SageMaker Python SDK เพื่อปรับแต่งและปรับใช้โมเดลเหล่านี้ได้ เรายังกล่าวถึงเทคนิคการปรับแต่งอย่างละเอียด ประเภทอินสแตนซ์ และไฮเปอร์พารามิเตอร์ที่รองรับอีกด้วย นอกจากนี้ เรายังให้คำแนะนำเพื่อเพิ่มประสิทธิภาพการฝึกอบรมโดยอิงจากการทดสอบต่างๆ ที่เราทำ ดังที่เราเห็นจากผลลัพธ์ของการปรับแต่งโมเดลสามแบบอย่างละเอียดบนชุดข้อมูลสองชุด การปรับแต่งแบบละเอียดจะช่วยปรับปรุงการสรุปเมื่อเปรียบเทียบกับโมเดลที่ไม่ได้ปรับแต่งแบบละเอียด ในขั้นตอนถัดไป คุณสามารถลองปรับแต่งโมเดลเหล่านี้บนชุดข้อมูลของคุณเองได้โดยใช้โค้ดที่ให้ไว้ในที่เก็บ GitHub เพื่อทดสอบและเปรียบเทียบผลลัพธ์สำหรับกรณีการใช้งานของคุณ

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

ดร.ซิน หวาง เป็นนักวิทยาศาสตร์ประยุกต์อาวุโสสำหรับอัลกอริทึมในตัวของ Amazon SageMaker JumpStart และ Amazon SageMaker เขามุ่งเน้นไปที่การพัฒนาอัลกอริธึมการเรียนรู้ของเครื่องที่ปรับขนาดได้ ความสนใจในงานวิจัยของเขาอยู่ในขอบเขตของการประมวลผลภาษาธรรมชาติ การเรียนรู้เชิงลึกที่อธิบายได้เกี่ยวกับข้อมูลแบบตาราง และการวิเคราะห์ที่มีประสิทธิภาพของการจัดกลุ่มพื้นที่เวลา-อวกาศแบบไม่มีพารามิเตอร์ เขาได้เผยแพร่เอกสารมากมายในการประชุม ACL, ICDM, KDD และ Royal Statistical Society: Series A

วิชาล ยาลามันชาลี เป็นสถาปนิกโซลูชั่นสตาร์ทอัพที่ทำงานร่วมกับบริษัท AI, หุ่นยนต์ และยานยนต์อัตโนมัติในระยะเริ่มต้น Vishaal ทำงานร่วมกับลูกค้าเพื่อนำเสนอโซลูชัน ML ที่ล้ำสมัย และมีความสนใจเป็นการส่วนตัวในการเรียนรู้แบบเสริมกำลัง การประเมิน LLM และการสร้างโค้ด ก่อนที่จะมาร่วมงานกับ AWS นั้น Vishaal สำเร็จการศึกษาระดับปริญญาตรีที่ UCI โดยเน้นด้านชีวสารสนเทศศาสตร์และระบบอัจฉริยะ

มีนคชีสันดาราม ทันดาวารายัน ทำงานให้กับ AWS ในฐานะผู้เชี่ยวชาญด้าน AI/ ML เขามีความหลงใหลในการออกแบบ สร้างสรรค์ และส่งเสริมประสบการณ์ข้อมูลและการวิเคราะห์ที่คำนึงถึงมนุษย์เป็นหลัก Meena มุ่งเน้นไปที่การพัฒนาระบบที่ยั่งยืนซึ่งมอบความได้เปรียบในการแข่งขันที่สามารถวัดผลได้สำหรับลูกค้าเชิงกลยุทธ์ของ AWS Meena เป็นนักเชื่อมต่อและนักคิดด้านการออกแบบ และมุ่งมั่นที่จะขับเคลื่อนธุรกิจไปสู่แนวทางใหม่ในการทำงานผ่านนวัตกรรม การบ่มเพาะ และการทำให้เป็นประชาธิปไตย

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

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• PlatoData.Network Vertical Generative Ai เพิ่มพลังให้กับตัวเอง เข้าถึงได้ที่นี่.
• เพลโตไอสตรีม. Web3 อัจฉริยะ ขยายความรู้ เข้าถึงได้ที่นี่.
• เพลโตESG. คาร์บอน, คลีนเทค, พลังงาน, สิ่งแวดล้อม แสงอาทิตย์, การจัดการของเสีย. เข้าถึงได้ที่นี่.
• เพลโตสุขภาพ เทคโนโลยีชีวภาพและข่าวกรองการทดลองทางคลินิก เข้าถึงได้ที่นี่.
• ที่มา: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/