การเพิ่มประสิทธิภาพความชอบโดยตรง: คู่มือฉบับสมบูรณ์

import torch
import torch.nn.functional as F

<p>class DPOTrainer:
def __init__(self, model, ref_model, beta=0.1, lr=1e-5):
self.model = model
self.ref_model = ref_model
self.beta = beta
self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)</p>

<p>def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
&quot;&quot;&quot;
pi_logps: ลอการิทึมของความน่าจะเป็นของนโยบาย, รูป (B,)
ref_logps: ลอการิทึมของความน่าจะเป็นของโมเดลอ้างอิง, รูป (B,)
yw_idxs: ดัชนีของการเติมคำที่ชอบ, รูป (T,)
yl_idxs: ดัชนีของการเติมคำที่ไม่ชอบ, รูป (T,)
beta: อุณหภูมิที่ควบคุมความเข้มของการลงโทษ KL</p>

<p># ดึงลอการิทึมของความน่าจะเป็นสำหรับการเติมคำที่ชอบและไม่ชอบ
pi_yw_logps, pi_yl_logps = pi_logps[yw_idxs], pi_logps[yl_idxs]
ref_yw_logps, ref_yl_logps = ref_logps[yw_idxs], ref_logps[yl_idxs]</p>

<p># คำนวณอัตราส่วนลอการิทึม
pi_logratios = pi_yw_logps - pi_yl_logps
ref_logratios = ref_yw_logps - ref_yl_logps</p>

<p># คำนวณการเสียหายของ DPO
losses = -F.logsigmoid(self.beta * (pi_logratios - ref_logratios))
rewards = self.beta * (pi_logps - ref_logps).detach()</p>

return losses.mean(), rewards

<p>def train_step(self, batch):
x, yw_idxs, yl_idxs = batch
self.optimizer.zero_grad()</p>

<p># คำนวณลอการิทึมของความน่าจะเป็นสำหรับโมเดลและโมเดลอ้างอิง
pi_logps = self.model(x).log_softmax(-1)
ref_logps = self.ref_model(x).log_softmax(-1)</p>

<p># คำนวณการเสียหาย
loss, _ = self.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)
loss.backward()
self.optimizer.step()</p>

return loss.item()

<p># การใช้งาน
model = YourLanguageModel() # เริ่มต้นโมเดลของคุณ
ref_model = YourLanguageModel() # โหลดโมเดลอ้างอิงที่ฝึกไว้แล้ว
trainer = DPOTrainer(model, ref_model)</p>

<p>for batch in dataloader:
loss = trainer.train_step(batch)
print(f&quot;การเสียหาย: {loss}&quot;)

ความท้าทายและทิศทางในอนาคต

แม้ว่า DPO จะมีข้อดีหลายประการ แต่ยังคงมีความท้าทายและพื้นที่สำหรับการวิจัยต่อไป:

ก) การขยายขนาดไปยังโมเดลขนาดใหญ่:

การนำ DPO ไปใช้กับโมเดลที่มีพารามิเตอร์หลายร้อยพันล้านยังคงเป็นความท้าทายที่เปิดอยู่ นักวิจัยกำลังสำรวจเทคนิคต่างๆ เช่น:

• วิธีการปรับให้เหมาะสมที่มีประสิทธิภาพ (เช่น LoRA, prefix tuning)
• การปรับปรุงการฝึกแบบกระจาย
• การตรวจสอบเกรเดียนต์และการฝึกแบบมีประสิทธิภาพผสม

ตัวอย่างการใช้ LoRA กับ DPO:

<p>from peft import LoraConfig, get_peft_model</p>

<p>class DPOTrainerWithLoRA(DPOTrainer):
def __init__(self, model, ref_model, beta=0.1, lr=1e-5, lora_rank=8):
lora_config = LoraConfig(
r=lora_rank,
lora_alpha=32,
target_modules=[&quot;q_proj&quot;, &quot;v_proj&quot;],
lora_dropout=0.05,
bias=&quot;none&quot;,
task_type=&quot;CAUSAL_LM&quot;
)
self.model = get_peft_model(model, lora_config)
self.ref_model = ref_model
self.beta = beta
self.optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)</p>

<p># การใช้งาน
base_model = YourLargeLanguageModel()
dpo_trainer = DPOTrainerWithLoRA(base_model, ref_model)

ข) การปรับให้เหมาะสมแบบหลายงานและแบบไม่ต้องฝึกมาก:

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

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

ค) การจัดการความชอบที่ไม่ชัดเจนหรือขัดแย้ง:

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

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

ตัวอย่างการสร้างแบบจำลองความชอบแบบความน่าจะเป็น:

<p>class ProbabilisticDPOTrainer(DPOTrainer):
def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob):
# คำนวณอัตราส่วนลอการิทึม
pi_yw_logps, pi_yl_logps = pi_logps[yw_idx], pi_logps[yl_idxs]
ref_yw_logps, ref_yl_logps = ref_logps[yw_idx], ref_logps[yl_idxs]</p>

<p>log_ratio_diff = pi_yw_logps.sum(-1) - pi_yl_logps.sum(-1)
loss = -(preference_prob * F.logsigmoid(self.beta * log_ratio_diff) +
(1 - preference_prob) * F.logsigmoid(-self.beta * log_ratio_diff))
return loss.mean()</p>

<p># การใช้งาน
trainer = ProbabilisticDPOTrainer(model, ref_model)
loss = trainer.compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs, preference_prob=0.8) # ความมั่นใจ 80% ในความชอบ

ง) การรวม DPO กับเทคนิคการจัดแนวอื่นๆ:

การรวม DPO กับวิธีการจัดแนวอื่นๆ อาจนำไปสู่ระบบที่มีความทนทานและสามารถใช้งานได้จริงมากขึ้น:

• หลักการ AI ที่เป็นรูปธรรมสำหรับการสร้างข้อจำกัดอย่างชัดเจน
• การถกเถียงและการสร้างแบบจำลองรางวัลแบบเรียกซ้ำสำหรับการค้นหาความชอบที่ซับซ้อน
• การเรียนรู้แบบผกผันเพื่อสร้างฟังก์ชันรางวัลที่ซ่อนอยู่

ตัวอย่างการรวม DPO กับหลักการ AI ที่เป็นรูปธรรม:

<p>class ConstitutionalDPOTrainer(DPOTrainer):
def __init__(self, model, ref_model, beta=0.1, lr=1e-5, constraints=None):
super().__init__(model, ref_model, beta, lr)
self.constraints = constraints or []</p>

<p>def compute_loss(self, pi_logps, ref_logps, yw_idxs, yl_idxs):
base_loss = super().compute_loss(pi_logps, ref_logps, yw_idxs, yl_idxs)</p>

<p>constraint_loss = 0
for constraint in self.constraints:
constraint_loss += constraint(self.model, pi_logps, ref_logps, yw_idxs, yl_idxs)</p>

return base_loss + constraint_loss

<p># การใช้งาน
def safety_constraint(model, pi_logps, ref_logps, yw_idxs, yl_idxs):
# ต้องเขียนลอจิกการตรวจสอบความปลอดภัย
unsafe_score = compute_unsafe_score(model, pi_logps, ref_logps)
return torch.relu(unsafe_score - 0.5) # ลงโทษหากคะแนนความไม่ปลอดภัยมากกว่า 0.5</p>

<p>constraints = [safety_constraint]
trainer = ConstitutionalDPOTrainer(model, ref_model, constraints=constraints)</p>

ข้อพิจารณาในทางปฏิบัติและแนวทางที่ดีที่สุด

เมื่อนำ DPO ไปใช้ในแอปพลิเคชันจริง ควรพิจารณาเคล็ดลับต่อไปนี้:

ก) คุณภาพของข้อมูล: คุณภาพของชุดข้อมูลความชอบมีความสำคัญอย่างมาก ตรวจสอบให้แน่ใจว่าชุดข้อมูลของคุณ:

• ครอบคลุมช่วงกว้างของอินพุตและพฤติกรรมที่ต้องการ
• มีการจัดอันดับความชอบที่สอดคล้องและเชื่อถือได้
• สมดุลระหว่างประเภทความชอบต่างๆ (เช่น ความถูกต้อง, ความปลอดภัย, สไตล์)

ข) การปรับพารามิเตอร์: แม้ว่า DPO จะมีพารามิเตอร์น้อยกว่า RLHF การปรับพารามิเตอร์ยังคงมีความสำคัญ:

• β (เบต้า): ควบคุมการแลกเปลี่ยนระหว่างความพึงพอใจของความชอบและความแตกต่างจากโมเดลอ้างอิง เริ่มต้นด้วยค่าระหว่าง 0.1-0.5
• อัตราการเรียนรู้: ใช้อัตราการเรียนรู้ที่ต่ำกว่าการปรับให้เหมาะสมมาตรฐาน โดยทั่วไปอยู่ในช่วง 1e-6 ถึง 1e-5
• ขนาดแบตช์: ขนาดแบตช์ที่ใหญ่กว่า (32-128) มักจะทำงานได้ดีสำหรับการเรียนรู้ความชอบ

ค) การปรับปรุงแบบซ้ำๆ: DPO สามารถใช้ซ้ำๆ:

1. ฝึกโมเดลเริ่มต้นโดยใช้ DPO
2. สร้างคำตอบใหม่โดยใช้โมเดลที่ฝึกไว้
3. รวบรวมข้อมูลความชอบใหม่เกี่ยวกับคำตอบเหล่านี้
4. ฝึกซ้ำโดยใช้ชุดข้อมูลที่ขยาย

การเพิ่มประสิทธิภาพความชอบโดยตรง

รูปภาพนี้แสดงผลการทำงานของ LLMs เช่น GPT-4 เมื่อเปรียบเทียบกับการตัดสินของมนุษย์ข้ามเทคนิคการฝึกต่างๆ รวมถึงการเพิ่มประสิทธิภาพความชอบโดยตรง (DPO), การปรับให้เหมาะสมแบบดูแล (SFT), และการเพิ่มประสิทธิภาพนโยบายแบบโปรกซิมอล (PPO) ตารางแสดงให้เห็นว่า GPT-4 สามารถสร้างเนื้อหาที่สอดคล้องกับความชอบของมนุษย์ โดยเฉพาะในงานสรุปผล

กรณีศึกษาและการประยุกต์ใช้

เพื่อแสดงถึงประสิทธิผลของ DPO มาทำความรู้จักกับกรณีศึกษาและรูปแบบการใช้งานจริงบางตัวอย่าง:

• การเพิ่มประสิทธิภาพความชอบโดยตรงแบบซ้ำๆ: พัฒนาโดย Snorkel (2023) รูปแบบนี้รวมการวาดตัวอย่างการปฏิเสธเข้ากับ DPO ทำให้สามารถเลือกข้อมูลฝึกที่มีคุณภาพสูงได้ดีขึ้น
• IPO (การเพิ่มประสิทธิภาพความชอบแบบซ้ำๆ): เสนอโดย Azar et al. (2023) IPO เพิ่มเทอมการปรับให้เหมาะสมเพื่อป้องกันการปรับให้เหมาะสมมากเกินไป ซึ่งเป็นปัญหาทั่วไปในการปรับให้เหมาะสมตามความชอบ
• KTO (การถ่ายโอนความรู้): รูปแบบล่าสุดจาก Ethayarajh et al. (2023) KTO ไม่ใช้ความชอบแบบทวินามอีกต่อไป แต่เน้นการถ่ายโอนความรู้จากโมเดลอ้างอิงไปยังนโยบาย
• การเพิ่มประสิทธิภาพความชอบโดยตรงแบบหลายโหมดสำหรับการเรียนรู้ข้ามโดเมน โดย Xu et al. (2024): การนำ DPO ไปใช้กับโหมดต่างๆ เช่น ข้อความ, รูปภาพ, และเสียง แสดงให้เห็นถึงความสามารถในการจัดแนวโมเดลกับความชอบของมนุษย์ข้ามข้อมูลหลายรูปแบบ