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

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

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

לסקירה מרוכזת של כל השיטות המומלצות ל-GKE, אפשר לעיין במאמר שיטות מומלצות ל-GKE.

מטרות

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

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

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

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

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

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

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

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

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

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

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

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

שיטה מומלצת: Tensor parallelism

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

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

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

TGI

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

במסמכי התיעוד של Hugging Face מופיעה רשימת המודלים שנתמכים ב-tensor parallelism.

בקטע הקוד הבא מוצג איך לבצע אופטימיזציה של מודל Gemma 7B שעבר כוונון לפי הוראות באמצעות מקביליות טנסור ושני GPUs מסוג 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. בקטע הזה נציג אסטרטגיות לאופטימיזציה של שכבת הקשב, כמו paged attention ו-flash attention. האסטרטגיות האלה משפרות את יעילות הזיכרון, ומאפשרות רצפי קלט ארוכים יותר וזמן המתנה קצר יותר של ה-GPU. בקטע הזה מוסבר גם איך אפשר לשנות את הגדלים של הקלט והפלט של המודל כדי להתאים למגבלות הזיכרון ולבצע אופטימיזציה למסגרות ספציפיות של הצגת מודעות.

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

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

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

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

  • Paged attention: Paged attention משפר את ניהול הזיכרון במודלים גדולים וברצפי קלט ארוכים באמצעות טכניקות של חלוקה לדפים, בדומה לזיכרון וירטואלי של מערכת הפעלה. כך אפשר לצמצם את הפרגמנטציה והשכפול במטמון ה-KV, ולהזין רצפים ארוכים יותר בלי לחרוג ממגבלת הזיכרון של ה-GPU.
  • Flash attention: Flash attention מצמצם את צווארי הבקבוק בזיכרון ה-GPU על ידי מזעור העברות הנתונים בין זיכרון ה-RAM של ה-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, חורג מקיבולת הזיכרון של מעבד NVIDIA L4 GPU יחיד. כדי לפרוס ב-L4, מגבילים את האורך המשולב של ההנחיות והפלט על ידי הגדרת --max-model-len לערך מתחת ל-640. ההתאמה הזו מאפשרת להריץ את המודל ב-GPU יחיד מסוג 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: הגדלת מספר הרפליקות (Pods) של השרת כדי לחלק את עומס העבודה.
  • ‫שימוש במקביליות טנסור: למודלים גדולים שחורגים מהקיבולת של GPU יחיד, אפשר להשתמש במקביליות טנסור כדי לפזר את החישובים על פני כמה מעבדי GPU. במודלים קטנים יותר, כדאי להשתמש בכמה רפליקות עם מקביליות טנסור של '1' כדי להימנע מתקורה.
  • בקשות Batch וכימות: משלבים בקשות Batch ובוחנים שיטות כימות ששומרות על רמת דיוק קבילה.
יעילות עלות
  • בחירת מודלים קטנים יותר: בחירת מודלים בתוך משפחה שמתאימים למגבלות המשאבים ולתקציב שלכם.
  • החלת קוונטיזציה: אפשר להשתמש בקוונטיזציה כדי להפחית את דרישות הזיכרון, במיוחד כשעובדים עם מודלים גדולים יותר.
  • הגבלת חלון ההקשר: מגבילים את חלון ההקשר כדי להפחית עוד יותר את השימוש בזיכרון ולאפשר הרצה במעבדי GPU קטנים וחסכוניים יותר.

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