כיצד לבצע כוונון עדין ל-LLM [ומתי עדיף להשתמש ב-RAG או בפרומפטים]

כוונון עדין (fine-tuning) של מודל שפה גדול (LLM) פירושו שיפור של LLM שעבר אימון מקדים באמצעות מערך נתונים קטן וייעודי למשימה, כך שיפיק פלטים שלא ניתן להשיג באמצעות פרומפטים בלבד.

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

אם אתם לא מרוצים מהפלטים של ה-LLM, שפרו קודם את הפרומפטים ואת היצירה המועשרת באחזור (RAG). כוונון עדין משנה את האופן שבו ה-LLM מתנהג. כשאתם צריכים שהמודל ישתמש במידע עדכני או קנייני, פרומפטים ו-RAG הם בדרך כלל בחירה טובה יותר.

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

מהו כוונון עדין של LLM ובמה הוא שונה מאימון מקדים של LLM

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

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

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

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

כדי לשפר את הביצועים של LLM, טפסו בסולם בהדרגה: פרומפטים -> RAG -> כוונון עדין.

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

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

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

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

סימנים לכך שהפרומפטים אולי הגיעו לגבול יכולתם:

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

גם אז, נסו קודם את התיקונים הזולים יותר ברמת הפרומפט. השתמשו בדוגמאות few-shot כדי להראות למודל את הדפוס (זוגות קלט/פלט), בשרשור פרומפטים (prompt chaining) כדי לפצל משימות קשות לשלבים קטנים יותר, או בקריאה לפונקציות (function calling) כדי להעביר לכלים חיצוניים חיפושים מדויקים או חישובים.

מתי RAG הגיוני יותר מכוונון עדין של המודל

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

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

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

החיסרון של RAG? זו שכבה נוספת שצריך לבנות ולתחזק, והיא מוסיפה השהיה.

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

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

גם כשכוונון עדין הוא הכלי הנכון, הוא כרוך בעלויות ובסיכונים:

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

שיטות הכוונון העדין העיקריות

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

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

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

בדרגות (ranks) נמוכות, PEFT לומד פחות מכוונון עדין מלא, אבל העלאת הדרגה וכוונון קצב הלמידה סוגרים את רוב הפער במשימות של כוונון להנחיות (instruction tuning).

שיטות PEFT כוללות:

• LoRA (Low-Rank Adaptation): נקודת הפתיחה המקובלת. השיטה מקפיאה את המשקלים המקוריים ומאמנת קבוצה קטנה של פרמטרי מתאם (adapter) שנוספים למודל, לרוב פחות מ-1% מסך הפרמטרים, כך שאפשר להריץ אותה על GPU צרכני יחיד.
• QLoRA (Quantized Low-Rank Adaptation): השיטה דוחסת את מודל הבסיס לדיוק של 4 ביט לפני החלת LoRA, וכך מאפשרת כוונון עדין של מודל גדול על GPU יחיד.

בנוסף לשיטות האלה, אנחנו משתמשים בשיטות של כוונון להנחיות (instruction tuning) וכוונון להעדפות (preference tuning), החל מ-RLHF (Reinforcement Learning from Human Feedback, למידת חיזוק ממשוב אנושי) ועד חלופות קלות יותר כמו Direct Preference Optimization (DPO) ו-Odds Ratio Preference Optimization (ORPO), כדי לעצב את האופן שבו המודל פועל לפי הנחיות ותואם להעדפות אנושיות.

איך לבצע כוונון עדין ל-LLM שלב אחר שלב

אחרי שהחלטתם שכוונון עדין של LLM הוא הצעד הנכון, הנה תהליך העבודה.

הגדלה

שלב 1: הגדירו את המשימה ואת האופן שבו תמדדו הצלחה

החליטו איזו התנהגות אתם רוצים לקבל מה-LLM ואיך תדעו שהשגתם אותה.

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

לאחר מכן, הגדירו מהי הצלחה. אפשרויות נפוצות כוללות:

• תקינות הפלט: למשל, האם ניתן לנתח את התוצאה כ-JSON תקין, או האם היא תואמת למבנה ה-Markdown שאתם צריכים?
• ציונים אוטומטיים: השתמשו במדדים כמו BLEU או ROUGE, שמשווים טקסט שנוצר לתשובות ייחוס, או בדיוק המשימה על קבוצת נתונים מתויגת.
• דירוגים אנושיים: מחוון ניקוד או מחוון עובר/נכשל לאיכויות שסקריפט מתקשה להעריך, כמו טון או מידת התועלת.
• אמינות בקלטים קשים: האם המודל מתמודד עם הקלטים החריגים שהכשילו את מודל הבסיס?

שלב 2: הכינו את מערך הנתונים

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

ארגנו את הנתונים כזוגות של הנחיה/תגובה בפורמט JSONL, שבו כל שורה מכילה את הקלט (וכל הקשר נוסף) ואת הפלט המדויק שאתם רוצים לקבל.

לדוגמה, עיינו במערכי נתונים ציבוריים כמו Alpaca-cleaned להנחיות כלליות או Dolly של Databricks, או במערך הייעודי banking77, שכולל יותר מ-13,000 פניות תמיכה אמיתיות המתויגות לפי 77 כוונות.

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

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

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

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

שלב 3: בחרו מודל בסיס ושיטה

התחילו עם מודל קוד פתוח קטן בגודל של 3 עד 7 מיליארד פרמטרים ועם שיטת כוונון עדין חסכונית בפרמטרים כמו LoRA או QLoRA.

משפחות מודלים פתוחות כמו Llama, Mistral ו-Qwen מספקות בסיס חזק שאפשר לארח בעצמכם, ושיטות PEFT שומרות על דרישות חומרה נמוכות: QLoRA מבצעת קוונטיזציה של מודל הבסיס ל-4 ביט, כך שכוונון עדין של מודל 7B דורש רק כרטיס צרכני עם 16–24GB. כוונון עדין מלא של אותו מודל דורש פי כמה וכמה יותר זיכרון.

שלב 4: הגדירו את היפר-הפרמטרים של האימון

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

• קצב הלמידה קובע את גודלו של כל עדכון של המשקלים. מחקר של Biderman ועמיתיו משנת 2024 מצא שקצבי הלמידה האופטימליים עבור LoRA היו גבוהים בערך פי עשרה מאלה של כוונון עדין מלא, בדרך כלל 5e-5 עד 5e-4 לעומת 1e-5 עד 5e-5. המחקר ממליץ לבדוק טווח של 1e-5 עד 5e-4 ולהשתמש בערך הגבוה ביותר שמאפשר אימון יציב.
• גודל אצווה הוא מספר הדוגמאות שהמודל לומד מהן לפני כל עדכון משקלים. ב-GPU יחיד, השתמשו באצווה קטנה של 1 עד 8 דוגמאות לכל התקן ובצבירת גרדיאנטים כדי להגיע לאצווה אפקטיבית של כ-16 עד 64.
• מספר האפוקים הוא מספר הפעמים שהמודל עובר על מערך הנתונים המלא. כשמאמנים את המודל לבצע משימות ספציפיות, 1–3 אפוקים הם כלל אצבע טוב, אבל הרצות LoRA דורשות לעיתים קרובות יותר.
• דרגת LoRA (r) קובעת את הקיבולת של המתאם, כלומר כמה הוא מסוגל ללמוד. התחילו בדרגה של 8 עד 32 למשימות פשוטות יותר והעלו אותה למשימות קשות יותר: במחקר ה-LoRA של Biderman ועמיתיו שצוטט לעיל, כוונון הוראות של מודל 7B על קוד דרש דרגה 256 כדי להשתוות לכוונון עדין מלא, בעוד שבמתמטיקה דרגה 64 התקרבה לכך.
• אורך הרצף המרבי הוא הקלט הארוך ביותר שההרצה תעבד. הגדירו אותו כך שיכסה את הדוגמאות הארוכות ביותר שלכם, עד לגודל חלון ההקשר של המודל, שכן כל קלט ארוך יותר ייקטע.
• חימום ותזמון קובעים כיצד קצב הלמידה עולה בהדרגה ומשתנה לאורך ההרצה. חימום קצר ודעיכה קוסינוסית הם ברירות המחדל המקובלות. עם זאת, המחקר של Pareja ועמיתיו על מודלים קטנים מצא שוויתור על החימום לא פגע בציונים הסופיים.

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

שלב 5: אימון ומעקב אחר ההפסד

במהלך האימון, עקבו אחר עקומות ההפסד של האימון ושל האימות כדי לוודא שהתהליך עובד.

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

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

הגדלה

שלב 6: הערכה ולאחר מכן פריסה

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

כשהמודל עומד בהם, יש לכם שתי דרכים לפרוס אותו:

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

השתמשו ב-Perplexity כדי לתת ל-LLM שלכם גישה למידע עדכני

כוונון עדין הוא הבחירה הנכונה כשאתם רוצים להתאים את התנהגות המודל לצרכים שלכם.

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

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

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

שאלות נפוצות על כוונון עדין של LLM

האם אפשר לבצע כוונון עדין ל-LLM בחינם?

כן, אפשר לבצע כוונון עדין ל-LLM פתוח וקטן בחינם. לדוגמה, החבילה החינמית של Google Colab מספקת מספיק משאבי GPU כדי להריץ QLoRA על מודל בגודל 3B עד 8B, וזה די והותר למשימה ממוקדת. תתחילו לשלם כשתצטרכו יותר זיכרון, הרצות ארוכות יותר או מודל בסיס גדול יותר ממה שהחבילה החינמית יכולה להכיל.

האם צריך GPU משלכם, או שאפשר לבצע כוונון עדין בענן?

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

כמה זמן לוקח כוונון עדין של LLM?

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

מודלים גדולים יותר או עשרות אלפי דוגמאות מאריכים את משך ההרצה ליום או יותר: הרצות ה-LoRA של Emburse על מודל 7B נמשכו 8 שעות עבור 5,000 דוגמאות וכ-30 שעות עבור 50,000 דוגמאות על GPU יחיד של 40GB.

האם אפשר להמשיך לעדכן מודל מכוונן כשהנתונים שלכם משתנים?

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