המדריך היחיד שצריך לכם לקליברציה עדינה של Llama 3 או כל מודל אחר של קוד פתוח

קליברציה עדינה של מודלי שפה גדולים (LLM) כמו Llama 3 כוללת התאמה של מודל מוכן מראש למשימות ספציפיות באמצעות מאגר נתונים ספציפי לתחום. תהליך זה נוצל את הידע הקיים של המודל, מה שהופך אותו ליעיל וזול יותר בהשוואה לאימון מאפס. במדריך זה, נעבור דרך הצעדים לקליברציה עדינה של Llama 3 באמצעות QLoRA (Quantized LoRA), שיטה יעילה מבחינת פרמטרים שמזערת את השימוש בזיכרון ועלויות חישוב.

תצוגה כללית של קליברציה עדינה

קליברציה עדינה כוללת מספר צעדים מפתח:

1. בחירת מודל מוכן מראש: בחרו מודל בסיס שתואם את הארכיטקטורה הרצויה.
2. איסוף מאגר נתונים רלוונטי: אספו ועבדו מאגר נתונים ספציפי למשימה.
3. קליברציה עדינה: התאימו את המודל באמצעות מאגר הנתונים כדי לשפר את ביצועיו במשימות ספציפיות.
4. הערכה: העריכו את ביצועי המודל המקולבר באמצעות מדדים איכותיים וכמותיים.

מושגים וטכניקות

Fine-tuning Large Language Models

קליברציה עדינה מלאה

קליברציה עדינה מלאה עדכנית את כל הפרמטרים של המודל, מה שהופך אותו לספציפי למשימה החדשה. שיטה זו דורשת משאבים חישוביים משמעותיים ולעיתים קרובות אינה מעשית עבור מודלים גדולים מאוד.

קליברציה עדינה יעילה מבחינת פרמטרים (PEFT)

PEFT עדכנית רק תת-קבוצה של פרמטרים של המודל, מה שמפחית את דרישות הזיכרון והחישוב. טכניקות כמו Low-Rank Adaptation (LoRA) ו-Quantized LoRA (QLoRA) משתייכות לקטגוריה זו.

Low-Rank Adaptation (LoRA) ו-Quantized LoRA (QLoRA)

LoRA מקליברת רק מספר מטריצות בדרגה נמוכה, בעוד QLoRA מקטין את המטריצות האלה לקידוד נמוך יותר, מה שמפחית את השימוש בזיכרון עוד יותר.

שיטות קליברציה עדינה

1. קליברציה עדינה מלאה: שיטה זו כוללת אימון של כל הפרמטרים של המודל על מאגר הנתונים הספציפי למשימה.
2. קליברציה עדינה יעילה מבחינת פרמטרים (PEFT): PEFT עדכנית רק תת-קבוצה של פרמטרים, מה שמפחית את דרישות הזיכרון והחישוב.

מהו LoRA?

Comparing finetuning methods: QLORA enhances LoRA with 4-bit precision quantization and paged optimizers for memory spike management

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 לשם כך. פלטפורמות כמו 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

# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. טעינת מאגר הנתונים

נשתמש במאגר הנתונים DialogSum לשם כך:

עיבוד מאגר הנתונים לפי דרישות המודל, כולל יישום תבניות מתאימות ווידוא שפורמט הנתונים מתאים לקליברציה עדינה​ (Hugging Face)​​ (DataCamp)​.

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

בדיקת מבנה מאגר הנתונים:

print(dataset['test'][0])

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 לשם כך:

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 או מודלים אחרים מתקדמים ופתוחים, ישנן התאמות ושיקולים ספציפיים הנדרשים כדי להבטיח ביצועים אופטימליים. כאן ישנם הצעדים המפורטים והמחשבות על איך לגישה זו עבור מודלים שונים, כולל Llama 3, GPT-3, ו-Mistral.

5.1 שימוש ב-Llama 3

בחירת מודל:

• וודאו שיש לכם את מזהה המודל הנכון מ-Hugging Face model hub. לדוגמה, מודל Llama 3 עשוי להיזהה כ-meta-llama/Meta-Llama-3-8B ב-Hugging Face.
• וודאו לבקש גישה ולהיכנס לחשבון Hugging Face שלכם אם נדרש למודלים כמו Llama 3​ (Hugging Face)​​

טוקניזציה:

• השתמשו בטוקנאייזר המתאים עבור Llama 3, ווודאו שהוא תואם את המודל ותומך בתכונות הדרושות כמו ריפוד וטוקנים מיוחדים.

זיכרון וחישוב:

• קליברציה עדינה של מודלים גדולים כמו Llama 3 דורשת משאבים חישוביים משמעותיים. וודאו שסביבתכם, כמו הפלגת GPU חזקה, יכולה להתמודד עם דרישות הזיכרון והעיבוד. וודאו שהסביבה יכולה להתמודד עם דרישות הזיכרון, שניתן להקל עליהן באמצעות שיטות כמו QLoRA להפחתת הטביעה של הזיכרון​ (Hugging Face Forums)

דוגמה:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

טוקניזציה:

תלוי בשימוש הספציפי ודרישות המודל, וודאו קונפיגורציה נכונה של הטוקנאייזר ללא הגדרות מיותרות. לדוגמה, use_fast=True מומלץ לביצועים טובים יותר​ (Hugging Face)​​ (Weights & Biases)​.

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

5.2 שימוש במודלים פופולריים אחרים (למשל, GPT-3, Mistral)

בחירת מודל:

• עבור מודלים כמו GPT-3 ו-Mistral, וודאו שאתם משתמשים בשם המודל הנכון ובמזהה מ-Hugging Face model hub או מקורות אחרים.

טוקניזציה:

• דומה ל-Llama 3, וודאו שהטוקנאייזר מוגדר נכון ותואם את המודל.

זיכרון וחישוב:

• כל מודל עשוי להיות עם דרישות זיכרון שונות. התאימו את הסביבה בהתאם.

דוגמה עבור GPT-3:

model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

דוגמה עבור Mistral:

model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

שיקולי טוקניזציה: כל מודל עשוי להיות עם דרישות טוקניזציה ייחודיות. וודאו שהטוקנאייזר תואם את המודל ומוגדר נכון.

דוגמה טוקנאייזר Llama 3:

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

דוגמה טוקנאייזר GPT-3 ו-Mistral:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

7. בדיקת המודל עם Zero-Shot Inferencing

הערכת המודל הבסיסי עם קלט מדגם:

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"

# Generate output
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)

טוקניזציה של המאגר הנתונים המעובד:

def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)

max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)

הכנת המודל לקליברציה עדינה יעילה מבחינת פרמטרים:

original_model = prepare_model_for_kbit_training(original_model)

היפר-פרמטרים משחקים תפקיד חשוב באופטימיזציה של ביצועי המודל. כאן ישנם היפר-פרמטרים מפתח לשיקול:

1. קצב למידה: שולט במהירות בה המודל עדכן את פרמטריו. קצב למידה גבוה עשוי להוביל להתכנסות מהירה יותר אך עלול לעבור את הפתרון האופטימלי. קצב למידה נמוך מבטיח התכנסות עקבית אך עלול לדרוש יותר אפוכים.
2. גודל באטצ’: מספר הדוגמאות שנעובדות לפני שהמודל עודכן את פרמטריו. גודל באטצ’ גדול יותר עשוי לשפר יציבות אך דורש יותר זיכרון. גודל באטצ’ קטן יותר עלול להוביל ליותר רעש בתהליך האימון.
3. צעדי אגרגציה של גרדיאנט: פרמטר זה עוזר בחיקוי גודל באטצ’ גדול יותר על ידי אגרגציה של גרדיאנטים לאורך מספר צעדים לפני ביצוע עדכון פרמטר.
4. מספר אפוכים: מספר הפעמים שמאגר הנתונים השלם עובר דרך המודל. יותר אפוכים עשויים לשפר ביצועים אך עלולים להוביל לאובר-פיטינג אם לא ננהלים כראוי.
5. דעיכת משקל: טכניקת רגולריזציה למניעת אובר-פיטינג על ידי ענישה של משקולות גדולות.
6. מתזמן קצב למידה: מותאם את קצב הלמידה במהלך האימון כדי לשפר ביצועים והתכנסות.

התאימו את קונפיגורציית האימון על ידי כיוונון היפר-פרמטרים כמו קצב למידה, גודל באטצ’ וצעדי אגרגציה של גרדיאנט, תוך התחשבות בדרישות המודל והמשימה. לדוגמה, מודלים Llama 3 עשויים לדרוש קצבי למידה שונים בהשוואה למודלים קטנים יותר​ (Weights & Biases)​​ (GitHub)​

דוגמה לקונפיגורציית אימון

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-ביט. וודאו שיש לכם מספיק זיכרון GPU כדי להתמודד עם גודל הבאטצ’ וגודל המודל.

2. אובר-פיטינג

נטרו את מדדי האימון כדי למנוע אובר-פיטינג. השתמשו בטכניקות כמו הפסקה מוקדמת ודעיכת משקל.

3. אימון איטי

אופטימיזו את מהירות האימון על ידי כיוונון גודל הבאטצ’, קצב למידה ושימוש בצעדי אגרגציה של גרדיאנט.

4. איכות נתונים

וודאו שמאגר הנתונים נקי ומעובד היטב. איכות נתונים ירודה יכולה להשפיע משמעותית על ביצועי המודל.

מסקנה

קליברציה עדינה של מודלי שפה גדולים באמצעות QLoRA היא דרך יעילה להתאים מודלים מוכנים מראש למשימות ספציפיות עם עלות חישובית מופחתת. על ידי עקיבה אחר המדריך הזה, תוכלו לקלברת מודלים כמו PHI, Llama 3 או כל מודל אחר פתוח כדי להשיג ביצועים גבוהים במשימות הספציפיות שלכם.