שיטות מומלצות לאופטימיזציה של הסקת מסקנות של מודלים גדולים של שפה (LLM) באמצעות GPU ב-Google Kubernetes Engine‏ (GKE)

‫Google Kubernetes Engine‏ (GKE) מספק שליטה מדויקת בהסקת מסקנות של מודלים גדולים של שפה (LLM) עם ביצועים ועלויות אופטימליים. במדריך הזה מוסברות שיטות מומלצות לאופטימיזציה של היקש ופרסום של מודלים פתוחים של LLM עם יחידות GPU ב-GKE באמצעות מסגרות הפרסום vLLM ו-Text Generation Inference (TGI).

סיכום רשימת המשימות

מטרות

המדריך הזה מיועד ללקוחות של AI גנרטיבי, למשתמשי GKE חדשים או קיימים, למהנדסי למידת מכונה ולמהנדסי LLMOps (DevOps) שרוצים לבצע אופטימיזציה של עומסי העבודה של מודלים גדולים של שפה (LLM) באמצעות מעבדי GPU עם Kubernetes.

בסוף המדריך הזה, תוכלו:

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

סקירה כללית של שיטות אופטימיזציה להצגת מודלים של LLM

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

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

• Quantization
• Tensor parallelism
• אופטימיזציה של הזיכרון של המודל

בדוגמאות במדריך הזה נעשה שימוש במודל שפה גדול (LLM) של Gemma 7B יחד עם מסגרות ההגשה vLLM או TGI כדי להחיל את השיטות המומלצות האלה. עם זאת, המושגים והתכונות שמתוארים רלוונטיים לרוב מודלי השפה הגדולים הפופולריים בקוד פתוח.

לפני שמתחילים

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

1. כדי לקבל גישה למודל Gemma, להכין את הסביבה וליצור ולהגדיר משאבים, פועלים לפי ההוראות במדריכים הבאים: Cloud de Confiance by S3NS

   • להכניס לשימוש בסביבת הייצור מודלים פתוחים של Gemma באמצעות יחידות GPU ב-GKE עם vLLM
   • להכניס לשימוש בסביבת הייצור מודלים פתוחים של Gemma באמצעות GPU ב-GKE עם Hugging Face TGI

   חשוב לשמור את טוקן הגישה של Hugging Face בסוד של Kubernetes.

2. משכפלים את מאגר הדוגמאות https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/ לסביבת הפיתוח המקומית.

3. משנים את ספריית העבודה ל-/kubernetes-engine-samples/ai-ml/llm-serving-gemma/.

שיטה מומלצת: קוונטיזציה

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

קיימות שיטות שונות של קוונטיזציה, ולכל אחת מהן יש יתרונות וחסרונות ייחודיים. חלק מהשיטות, כמו AWQ ו-GPTQ, דורשות קוונטיזציה מראש וזמינות בפלטפורמות כמו Hugging Face או Kaggle. לדוגמה, אם מפעילים GPTQ על מודל Llama-2 13B ו-AWQ על מודל Gemma 7B, אפשר להפעיל את המודלים על GPU L4 יחיד במקום על שני GPU L4 ללא קוונטיזציה.

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

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

בוחרים אחת מהכרטיסיות האלה כדי לראות דוגמה להחלת קוונטיזציה באמצעות המסגרות TGI או vLLM:

args:
- --model-id=$(MODEL_ID)
- --num-shard=2
- --quantize=bitsandbytes

kubectl apply -f tgi/tgi-7b-bitsandbytes.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --quantization=awq
env:
- name: MODEL_ID
  value: google/gemma-7b-AWQ
resources:
  requests:
    nvidia.com/gpu: 1
  limits:
    nvidia.com/gpu: 1

kubectl apply -f vllm/vllm-7b-awq.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --kv-cache-dtype=fp8_e5m2
- --max-model-len=1200
resources:
  requests:
    cpu: "2"
    memory: "25Gi"
    ephemeral-storage: "25Gi"
    nvidia.com/gpu: 1
  limits:
    cpu: "2"
    memory: "25Gi"
    ephemeral-storage: "25Gi"
    nvidia.com/gpu: 1

kubectl apply -f vllm/vllm-7b-kvcache.yaml

שיטה מומלצת: מקביליות טנסור

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

מידע נוסף על הטכניקה הזו זמין במדריך Tensor Parallelism של Hugging Face.

בוחרים אחת מהכרטיסיות האלה כדי לראות דוגמה להחלת מקביליות טנסור באמצעות מסגרות TGI או vLLM:

args:
- --model-id=$(MODEL_ID)
- --num-shard=2

kubectl apply -f tgi/tgi-7b-it-tensorparallelism.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=2

kubectl apply -f vllm/vllm-7b-it-tensorparallelism.yaml

שיטה מומלצת: אופטימיזציה של זיכרון המודל

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

אופטימיזציה של שכבת תשומת הלב

שכבות של מנגנון קשב עצמי מאפשרות למודלים להבין את ההקשר במשימות של עיבוד שפה, כי המשמעות של מילים יכולה להשתנות בהתאם להקשר. עם זאת, השכבות האלה מאחסנות משקלים של טוקנים של קלט, מפתחות (K) וערכים (V) ב-vRAM של ה-GPU. לכן, ככל שרצף הקלט מתארך, הגודל וזמן החישוב גדלים באופן ריבועי.

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

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

• תשומת לב עם החלפה לדף: תשומת לב עם החלפה לדף משפרת את ניהול הזיכרון במודלים גדולים וברצפים ארוכים של קלט באמצעות טכניקות החלפה לדף, בדומה לזיכרון וירטואלי של מערכת הפעלה. כך מצמצמים את הפיצול והכפילות במטמון KV, ומאפשרים רצפים ארוכים יותר של קלט בלי שייגמר הזיכרון של ה-GPU.
• Flash attention: Flash attention מצמצם את צווארי הבקבוק בזיכרון ה-GPU על ידי מזעור העברות הנתונים בין זיכרון ה-RAM של ה-GPU לבין מטמון L1 במהלך יצירת טוקנים. כך נמנע זמן בלי פעילות של ליבות המחשוב, ומשפרים באופן משמעותי את הביצועים של היקש ואימון של מעבדי GPU.

התאמה של גודל הקלט והפלט של המודל

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

בוחרים באחת מהכרטיסיות האלה כדי לראות דוגמה להתאמת דרישות הזיכרון של הקלט והפלט של המודל במסגרות TGI או vLLM:

args:
- --model-id=$(MODEL_ID)
- --num-shard=1
- --max-total-tokens=3072 
- --max-batch-prefill-tokens=512
- --max-input-length=512
env:
- name: MODEL_ID
  value: google/gemma-7b

kubectl apply -f tgi/tgi-7b-token.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --max-model-len=600

kubectl apply -f vllm/vllm-7b-token.yaml

סיכום רשימת המשימות

המאמרים הבאים

• מדריך מקיף להגדרת מאגר תגים זמין במאמר הצגת מודל LLM עם כמה GPU ב-GKE.
• אם אתם צריכים פתרון להפעלת מודלים גדולים של שפה (LLM) שמנוהל בענן, אתם יכולים לפרוס את המודל באמצעות Vertex AI Model Garden.