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

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

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

סקירה מרוכזת של כל השיטות המומלצות ל-GKE זמינה במאמר שיטות מומלצות ל-GKE.

מטרות

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

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

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

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

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

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

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

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

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

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

    חשוב לשמור את טוקן הגישה ל-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:

TGI

‫GKE תומך באפשרויות הכימות הבאות עם TGI:

  • awq
  • gptq
  • eetq
  • bitsandbytes
  • bitsandbytes-nf4
  • bitsandbytes-fp4

שיטות הכימות AWQ ו-GPTQ דורשות מודלים שעברו כימות מראש, בעוד שכימות EETQ ו-bitsandbytes אפשר להחיל על כל מודל. מידע נוסף על האפשרויות האלה מפורט במאמר הזה ב-Hugging Face.

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

בקטע הקוד הבא אפשר לראות איך לבצע אופטימיזציה של Gemma 7B באמצעות קוונטיזציה של bitsandbytes באמצעות TGI ב-GKE.

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

כדי להחיל את ההגדרה הזו, משתמשים בפקודה הבאה:

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

vLLM

‫GKE תומך באפשרויות הכימות הבאות עם vLLM:

כדי להשתמש בכימות מודלים עם vLLM, המודלים צריכים להיות מכומתים מראש. כשמפעילים את זמן הריצה, מגדירים את הפרמטר –quantization.

בקטע הקוד הבא מוצג איך לבצע קוונטיזציה של מודל Gemma 7B באמצעות awq ב-vLLM ב-GKE:

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

שיפור זמן האחזור באמצעות קוונטיזציה של מטמון KV

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

כדי להפעיל את הכמותיזציה של מטמון FP8 E5M2 KV, מגדירים את הפרמטר --kv-cache-dtype fp8_e5m2:

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

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

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

TGI

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

רשימת המודלים שנתמכים במקביליות טנסור מופיעה במסמכי התיעוד של Hugging Face.

בקטע הקוד הבא מוצג איך לבצע אופטימיזציה של מודל Gemma 7B שעבר כוונון להוראות באמצעות מקביליות טנסור ושני כרטיסי GPU מסוג L4:

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

כדי להחיל את ההגדרה הזו, משתמשים בפקודה הבאה:

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

באשכולות GKE Autopilot, הפעלת הפקודה הזו יוצרת Pod עם דרישות מינימליות של משאבים של 21 vCPU ו-78‎ GiB זיכרון.

vLLM

‫vLLM תומך בהסקת מסקנות מקבילית של טנסורים מבוזרים. התכונה הזו מופעלת ב-vLLM כברירת מחדל אם יש יותר מ-GPU אחד.

בקטע הקוד הבא אפשר לראות איך אפשר לבצע אופטימיזציה של מודל Gemma 7B שעבר כוונון להוראות באמצעות מקביליות טנסור ושני כרטיסי GPU מסוג L4:

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

כדי להחיל את ההגדרה הזו, משתמשים בפקודה הבאה:

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

באשכולות GKE Autopilot, הפעלת הפקודה הזו יוצרת Pod עם דרישות מינימליות של משאבים של 21 vCPU ו-78‎ GiB זיכרון.

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

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

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

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

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

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

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

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

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

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

TGI

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

‫GKE תומך בפרמטרים הבאים של TGI לאופטימיזציה של דרישות הזיכרון של המודל:

בקטע הקוד הבא אפשר לראות איך מפרסמים מודל Gemma 7B שעבר כוונון להוראות באמצעות GPU L4 יחיד, עם הגדרות הפרמטרים --max-total-tokens=3072, --max-batch-prefill-tokens=512, --max-input-length=512:

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

vLLM

ב-vLLM, מגדירים את חלון ההקשר של המודל, שמשפיע ישירות על גודל מטמון KV ועל דרישות ה-RAM של ה-GPU. אורכי הקשר הקצרים יותר מאפשרים שימוש במעבדי GPU במחירים נוחים יותר. ערך ברירת המחדל הוא מספר האסימונים המקסימלי שהמודל מקבל. אם צריך, מגבילים את חלון ההקשר המקסימלי באמצעות --max-model-len MAX_MODEL_LEN.

לדוגמה, מודל Gemma 7B שעבר כוונון להוראות, עם אורך הקשר שמוגדר כברירת מחדל של 8,192, חורג מקיבולת הזיכרון של מעבד GPU יחיד מסוג NVIDIA L4. כדי לפרוס ב-L4, מגבילים את האורך המשולב של ההנחיות והפלט על ידי הגדרת --max-model-len לערך מתחת ל-640. השינוי הזה מאפשר להריץ את המודל במעבד גרפי L4 יחיד, למרות חלון ההקשר הגדול שלו כברירת מחדל.

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

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

כדי להחיל את ההגדרה הזו, משתמשים בפקודה הבאה:

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

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

יעד אופטימיזציה תרגל
זמן אחזור
  • ‫תעדוף מעבדי GPU חזקים: כדאי לשקול שדרוג למעבדי GPU עם יכולות חישוביות גבוהות יותר וזיכרון עם קצב העברת נתונים גבוה יותר.
  • כדאי לבדוק את הכמותיזציה: טכניקות כמו AWQ יכולות לשפר את זמן האחזור, אבל חשוב לשים לב לפשרות פוטנציאליות בדיוק.
תפוקה
  • ‫Scale horizontally: Increase the number of serving replicas (Pods) to distribute the workload.
  • ‫שימוש במקביליות טנסור: למודלים גדולים שחורגים מקיבולת GPU יחידה, משתמשים במקביליות טנסור כדי לפזר חישובים על פני כמה GPU. במודלים קטנים יותר, כדאי להשתמש בכמה רפליקות עם מקביליות טנסור של '1' כדי להימנע מתקורה.
  • ‫Batch requests and quantize: Combine requests and explore quantization techniques that maintain acceptable accuracy.
עלות-תועלת
  • בחירת מודלים קטנים יותר: בוחרים מודלים בתוך משפחה שמתאימים למגבלות המשאבים ולתקציב שלכם.
  • ‫Apply quantization: Use quantization to reduce memory requirements, particularly when dealing with larger models.
  • ‫Limit context length: Constrain the context length to further decrease memory usage and enable execution on smaller, more cost-effective GPUs.

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