ישנם בדרך כלל שלושה שלבים שונים של אימון עבור דגמי שפה גדולים:

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

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

3. יישור העדפות: השלב השלישי הוא יישור העדפות, שבו הדגם מאומן ללמוד מה המשתמש מעדיף בתגובות, או ליישר את הדגם לעקרונות מסוימים. זה נעשה לעתים קרובות באמצעות טכניקות כמו למידה מחיזוק מתגובות אנושיות (RLHF) או אופטימיזציית מדיניות ויכוח (DPO).

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

ישנן שלוש אפשרויות פופולריות לכוונון מפוקח:

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

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

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

כדי להגדיר את מתאמי ה-LoRA, יש כמה פרמטרים עיקריים לשקול:

1. דרגה: דרגת מתאמי ה-LoRA שולטת במספר הפרמטרים שיעודכנו במהלך הכוונון. דרגה נמוכה יותר פירושה פחות פרמטרים, מה שמקטין את דרישות ה-VRAM אך עשוי גם להגביל את יכולת ההסתגלות של הדגם. לעומת זאת, דרגה גבוהה יותר מאפשרת גמישות רבה יותר אך דורשת יותר VRAM.

2. LoRA Alpha: פרמטר זה שולט בתרומת מתאמי ה-LoRA למשקלי הדגם הסופיים. ערך LoRA Alpha גבוה יותר פירושו שמתאמי ה-LoRA יהיו בעלי השפעה חזקה יותר, בעוד ערך נמוך יותר פירושו שהם יהיו בעלי השפעה חלשה יותר.

3. LoRA Dropout: פרמטר זה שולט בשיעור הדריפה המיושם על מתאמי ה-LoRA במהלך האימון. הגדלת שיעור הדריפה יכולה לסייע במניעת יתר-התאמה, אך היא עשויה גם להפחית את ביצועי הדגם.

כדי להכין את הנתונים לכוונון, עלינו להגדיר את תבנית הפרומפט ולציין את אסימון סוף הרצף.

תבנית הפרומפט קריטית, מכיוון שהיא מגדירה את תבנית הנתונים הקלט שהדגם יאומן עליה. עבור משפחת Llama 3.1, נשתמש בתבנית הפרומפט של Alpaca, הכוללת הוראה והקלט המספק הקשר נוסף. מהדגם מצופה לייצר תגובה רלוונטית.

# תבנית הפרומפט של Alpaca
prompt_template = "להלן הוראה המתארת משימה המשולבת עם קלט המספק הקשר נוסף. ענה בתגובה רלוונטית.\n\nהוראה: {instruction}\nקלט: {input}\nפלט:"

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

# הגדר את אסימון סוף הרצף
end_token = "</s>"

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

כדי לאמן את הדגם, נשתמש במאמן SFT (כוונון מפוקח) מחבילת TRL, שנוצרה ומתוחזקת על ידי Hugging Face.

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

אנו גם מגדירים את אורך הרצף המרבי, שצריך להיות מבוסס על הדוגמאות בנתוני האימון שלך. שים לב שאורך רצף גבוה יותר יגדיל את דרישות ה-VRAM.

לאחר מכן, אנו מגדירים את טיעוני האימון, כמו ההתקן (במקרה זה GPU T4 ב-Google Colab עם כ-15GB VRAM) ומספר צעדי האימון.

לבסוף, אנו מפעילים את המאמן, וניתן לצפות בירידה בהפסד, שהיא סימן טוב להתקדמות האימון.

האימון נמשך כ-8 דקות, והזיכרון המשמר המרבי היה כ-8GB, שהם כ-53% מה-VRAM הזמין ב-GPU T4. זה מדגים את היעילות של גישת Unsloth, המאפשרת כוונון עם דרישת VRAM יחסית נמוכה.

כדי לבצע הסקה, ניתן להשתמש בקלאס או בשיטה for_inference בקלאס FastLanguageModel. עלינו לספק את הדגם המאומן והפרומפט הקלט בפורמט Alpaca. ניתן גם להגדיר את מספר האסימונים המרבי לייצור.

# בצע הסקה
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

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

# אפשר זרימה
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

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

כדי לשמור את הדגם המכוונן והמפענח, ניתן להשתמש בפונקציה save_pretrained() על הדגם והמפענח:

model.save_pretrained("path/to/save/model")
tokenizer.save_pretrained("path/to/save/tokenizer")

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

כדי לטעון את הדגם והמפענח השמורים, ניתן להשתמש באותה קלאס FastLanguageModel ולספק את התיקיות המקומיות:

model = FastLanguageModel.from_pretrained("path/to/save/model")
tokenizer = FastLanguageModel.from_pretrained("path/to/save/tokenizer")

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

תכונה נהדרת נוספת של Unsloth היא היכולת לשמור את הדגמים בפורמטים שונים, כמו דיוק נקודה צפה 16 סיביות עבור VLLM או ישירות בפורמט GGUF עבור LamaCPP. זה מאפשר פריסה קלה ושילוב עם פלטפורמות ומסגרות שונות.

Unsloth גם מציג ממשק משתמש חדש המבוסס על Gradio, המאפשר להריץ את הדגמים המאומנים באמצעות Unsloth ולהשתתף בשיחות אינטראקטיביות. ניתן לשכפל את מאגר Unsloth Studio ולהריץ את מחברת Colab המסופקת כדי לחוות תכונה זו.

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

כדי להשתמש בממשק השיחה, ניתן לשכפל את מאגר Unsloth studio ולהריץ את מחברת Google Colab המסופקת. זה יקים את הסביבה הנדרשת ויפעיל את ממשק השיחה, שבו ניתן להתחיל לשוחח עם דגם השפה.

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