คู่มือการปรับแต่ง Llama 3 หรือโมเดลโอเพ่นซอร์สอื่นๆ ที่คุณต้องการ

การปรับแต่งโมเดลภาษาขนาดใหญ่ (LLMs) เช่น Llama 3 เกี่ยวข้องกับการปรับโมเดลที่ได้รับการฝึกฝนมาแล้วให้เหมาะสมกับงานเฉพาะโดยใช้เซตข้อมูลเฉพาะโดเมน การปรับแต่งนี้ใช้ความรู้ที่มีอยู่แล้วของโมเดล ทำให้การปรับแต่งมีประสิทธิภาพและคุ้มค่าเมื่อเทียบกับการฝึกฝนจากศูนย์ ในคู่มือนี้ เราจะพาคุณผ่านขั้นตอนการปรับแต่ง Llama 3 โดยใช้ QLoRA (Quantized LoRA) ซึ่งเป็นวิธีการที่มีประสิทธิภาพในการปรับแต่งโดยลดการใช้หน่วยความจำและค่าใช้จ่ายในการคำนวณ

การปรับแต่งแบบทั่วไป

การปรับแต่งเกี่ยวข้องกับขั้นตอนหลักๆ ดังนี้

1. เลือกโมเดลที่ได้รับการฝึกฝนมาแล้ว: เลือกโมเดลฐานที่สอดคล้องกับโครงสร้างที่คุณต้องการ
2. รวบรวมและเตรียมข้อมูล: รวบรวมและเตรียมข้อมูลที่เฉพาะเจาะจงสำหรับงานของคุณ
3. การปรับแต่ง: ปรับโมเดลโดยใช้ข้อมูลเพื่อปรับปรุงประสิทธิภาพในการทำงานเฉพาะ
4. การประเมิน: ประเมินโมเดลที่ได้รับการปรับแต่งโดยใช้มาตรการคุณภาพและปริมาณ

แนวคิดและเทคนิค

การปรับแต่งโมเดลภาษาขนาดใหญ่

การปรับแต่งแบบเต็ม

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

การปรับแต่งแบบมีประสิทธิภาพ (PEFT)

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

การปรับแต่งแบบอันดับต่ำ (LoRA) และ Quantized LoRA (QLoRA)

LoRA ปรับแต่งเฉพาะเมทริกซ์อันดับต่ำบางส่วน ในขณะที่ QLoRA ควอนไทซ์เมทริกซ์เหล่านี้เพื่อลดการใช้หน่วยความจำเพิ่มเติม

วิธีการปรับแต่ง

1. การปรับแต่งแบบเต็ม: สิ่งนี้เกี่ยวข้องกับการฝึกฝนพารามิเตอร์ทั้งหมดของโมเดลในเซตข้อมูลเฉพาะงาน แม้ว่าวิธีนี้จะสามารถมีประสิทธิภาพสูง แต่ก็ใช้ทรัพยากรการคำนวณมากและต้องการหน่วยความจำที่สำคัญ
2. การปรับแต่งแบบมีประสิทธิภาพ (PEFT): PEFT อัปเดตเฉพาะพารามิเตอร์บางส่วนของโมเดล ทำให้ใช้หน่วยความจำน้อยลง เทคนิคอย่าง LoRA และ QLoRA อยู่ในหมวดหมู่นี้

LoRA คืออะไร?

การเปรียบเทียบวิธีการปรับแติง: QLORA เพิ่ม LoRA ด้วยควอนไทซ์ 4 บิตและตัวจัดการหน่วยความจำแบบเพจ

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

ข้อดีหลักของ LoRA:

• ประสิทธิภาพการใช้หน่วยความจำ: LoRA ลดการใช้หน่วยความจำโดยการปรับแต่งเฉพาะเมทริกซ์ขนาดเล็กแทนโมเดลทั้งหมด
• การนำกลับมาใช้ใหม่: โมเดลเดิมไม่เปลี่ยนแปลง และตัวปรับแต่ง LoRA หลายตัวสามารถใช้กับโมเดลเดียวกันได้ ทำให้จัดการงานหลายอย่างได้ด้วยการใช้หน่วยความจำน้อย

Quantized LoRA (QLoRA) คืออะไร?

QLoRA นำ LoRA ไปสู่ขั้นตอนต่อไปโดยการควอนไทซ์น้ำหนักของตัวปรับแต่ง LoRA ลงไปที่ความแม่นยำที่ต่ำกว่า (เช่น 4 บิตแทน 8 บิต) สิ่งนี้ลดการใช้หน่วยความจำและความต้องการในการจัดเก็บข้อมูลลงอย่างมาก ในขณะเดียวกันก็รักษาความสามารถในการทำงานไว้ใกล้เคียงกับโมเดลความแม่นยำเต็ม

ข้อดีหลักของ QLoRA:

• ประสิทธิภาพการใช้หน่วยความจำที่ดีขึ้น: โดยการควอนไทزن้ำหนัก QLoRA ลดความต้องการหน่วยความจำและจัดเก็บข้อมูลของโมเดลลงอย่างมาก
• การรักษาความสามารถในการทำงาน: แม้ว่าจะมีความแม่นยำที่ลดลง QLoRA ก็ยังคงรักษาความสามารถในการทำงานไว้ใกล้เคียงกับโมเดลความแม่นยำเต็ม

การปรับแต่งสำหรับงานเฉพาะ

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

การปรับแต่งในทางปฏิบัติ

การปรับแต่งแบบเต็มเทียบกับ PEFT

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

ขั้นตอนการนำไปใช้

1. ตั้งค่าสภาพแวดล้อม: ติดตั้งไลบรารี่ที่จำเป็นและตั้งค่าสภาพแวดล้อมการคำนวณ
2. โหลดและเตรียมข้อมูล: โหลดเซตข้อมูลและเตรียมให้เหมาะสมกับโมเดล
3. โหลดโมเดลที่ได้รับการฝึกฝนมาแล้ว: โหลดโมเดลฐานพร้อมกับการตั้งค่าควอนไทซ์หากใช้ QLoRA
4. การแบ่งคำ: แบ่งคำในเซตข้อมูลเพื่อเตรียมสำหรับการฝึกฝน
5. การฝึกฝน: ปรับแต่งโมเดลโดยใช้เซตข้อมูลที่เตรียมไว้
6. การประเมิน: ประเมินประสิทธิภาพของโมเดลโดยใช้มาตรการคุณภาพและปริมาณ

คู่มือทีละขั้นตอนในการปรับแต่ง LLM

การตั้งค่าสภาพแวดล้อม

เราจะใช้ Jupyter Notebook สำหรับการสาธิตนี้ แพลตฟอร์มอย่าง Kaggle ซึ่งให้การใช้ GPU ฟรี หรือ Google Colab เหมาะสำหรับการทดลองเหล่านี้

1. ติดตั้งไลบรารี่ที่จำเป็น

ขั้นแรก ให้แน่ใจว่าคุณมีไลบรารี่ที่จำเป็นติดตั้งแล้ว:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. นำไลบรารี่เข้ามาใช้และตั้งค่าสภาพแวดล้อม

import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# ปิดการบันทึก Weights and Biases
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. โหลดเซตข้อมูล

เราจะใช้เซตข้อมูล DialogSum สำหรับการสาธิตนี้:

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

4. สร้างการกำหนดค่า BitsAndBytes

เพื่อโหลดโมเดลในรูปแบบ 4 บิต:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)

5. โหลดโมเดลที่ได้รับการฝึกฝนมาแล้ว

โดยใช้โมเดล Phi-2 ของ Microsoft (MSFT ) สำหรับการสาธิตนี้:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

6. การแบ่งคำ

การกำหนดค่าตัวแบ่งคำ:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

การปรับแต่ง Llama 3 หรือโมเดลอื่นๆ

เมื่อปรับแต่งโมเดลอย่าง Llama 3 หรือโมเดลโอเพ่นซอร์สอื่นๆ ที่มีความก้าวหน้า มีข้อพิจารณาและการปรับแต่งเฉพาะที่จำเป็นต่อการรับประกันประสิทธิภาพที่ดีที่สุด

5.1 การใช้ Llama 3

การเลือกโมเดล:

• ให้แน่ใจว่าคุณมีไอดีโมเดลที่ถูกต้องจาก Hugging Face model hub สำหรับ Llama 3 อาจระบุเป็น meta-llama/Meta-Llama-3-8B บน Hugging Face
• ให้แน่ใจว่าคุณได้รับอนุญาตและเข้าสู่ระบบบัญชี Hugging Face ของคุณหากจำเป็นสำหรับโมเดลอย่าง Llama 3

7. ทดสอบโมเดลด้วยการอนุมานแบบซีโรช็อต

ประเมินโมเดลฐานด้วยข้อความตัวอย่าง:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"

# สร้างผลลัพธ์
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)

res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]

print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. การเตรียมเซตข้อมูล

แปลงคู่สนทนา-สรุปเป็นข้อความที่ต้องการ:

def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"

parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample

dataset = dataset.map(create_prompt_formats)

พารามิเตอร์และผลกระทบ

พารามิเตอร์มีบทบาทสำคัญในการเพิ่มประสิทธิภาพของโมเดล

ตัวอย่างการกำหนดค่าการฝึกฝน

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",
num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/",
)

10. การฝึกโมเดล

ตั้งค่าเทรนเนอร์และเริ่มฝึกฝน:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,
)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

การประเมินโมเดลที่ปรับแต่งแล้ว

หลังการฝึกฝน ให้ประเมินประสิทธิภาพของโมเดลโดยใช้มาตรการคุณภาพและปริมาณ

1. การประเมินของมนุษย์

เปรียบเทียบสรุปผลที่สร้างขึ้นด้วยสรุปผลที่เขียนโดยมนุษย์เพื่อประเมินคุณภาพ

2. การประเมินเชิงปริมาณ

ใช้มาตรการอย่าง ROUGE เพื่อประเมินประสิทธิภาพ:

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)

ความท้าทายทั่วไปและวิธีแก้ปัญหา

1. ข้อจำกัดของหน่วยความจำ

การใช้ QLoRA ช่วยลดปัญหาการใช้หน่วยความจำโดยการควอนไทزن้ำหนักโมเดลเป็น 4 บิต

2. การปรับแต่งมากเกินไป

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

3. การฝึกฝนที่ช้า

เพิ่มความเร็วในการฝึกฝนโดยการปรับขนาดชุดข้อมูล การเรียนรู้อัตรา และการใช้การสะสมเกรเดียนต์

4. คุณภาพของข้อมูล

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

สรุป

การปรับแต่งโมเดลภาษาขนาดใหญ่โดยใช้ QLoRA เป็นวิธีที่มีประสิทธิภาพในการปรับโมเดลที่ได้รับการฝึกฝนมาแล้วให้เหมาะสมกับงานเฉพาะโดยลดค่าใช้จ่ายในการคำนวณ โดยการปฏิบัติตามคู่มือนี้ คุณสามารถปรับแต่ง PHI, Llama 3 หรือโมเดลโอเพ่นซอร์สอื่นๆ เพื่อให้ได้ประสิทธิภาพสูงในงานของคุณ