חזרה לפיד
articlesמקור: MongoDB Official Blog (general)18.12.2025

איחוד מנות מבוסס טוקנים: הסקת מודלי הטמעה מהירה וזולה יותר לשאילתות

אמ;לק

Voyage AI מציגה שיטת Token-count-based Batching לפתרון צווארי בקבוק של Memory-bound בהסקת מודלי Embedding קצרים. האופטימיזציה מורידה זמני השהיה לטווח של 100-300ms ומוזילה עלויות תשתית. קריטי למפתחים שבונים מערכות RAG ומנועי וקטורים בזמן אמת.

סיכום בעברית: מערכת VibeSec · מדיניות המקורות

נוסף ל-VibeSec:

כותרת מקורית: Token-count-based Batching: Faster, Cheaper Embedding Inference for Queries

$cat article.txt

>Voyage AI מציגה שיטת Token-count-based Batching לפתרון צווארי בקבוק של Memory-bound בהסקת מודלי Embedding קצרים. האופטימיזציה מורידה זמני…

התוכן המלא בעברית

תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.

הסקת מסקנות (Inference) של מודלי Embedding נאבקת לעתים קרובות עם יעילות בעת הגשת כמויות גדולות של בקשות קצרות – דפוס נפוץ במערכות חיפוש, אחזור והמלצות. ב-Voyage AI ב-MongoDB, אנו מכנים בקשות קצרות אלו שאילתות (Queries), בעוד שבקשות אחרות מכונות מסמכים. בדרך כלל, יש להגיש שאילתות עם זמן השהיה (latency) נמוך מאוד (בדרך כלל 100–300 מילי-שניות).

השאילתות הן בדרך כלל קצרות, והתפלגות אורך האסימונים (tokens) שלהן מוטה מאוד. כתוצאה מכך, הסקת השאילתות נוטה להיות מוגבלת בזיכרון (memory-bound) ולא מוגבלת במחשוב (compute-bound). תעבורת השאילתות מאופיינת בתנודתיות גבוהה, ולכן מנגנוני Auto-scaling איטיים מדי. לסיכום, הגשת בקשות קצרות רבות ברצף היא פעולה לא יעילה בעליל.

בפוסט זה, אנו בוחנים כיצד ניתן להשתמש ב-Batching (יצירת אצוות) כדי להגיש שאילתות בצורה יעילה יותר. תחילה נדון בהסרת ריפוד (Padding removal) במנועי הסקה מודרניים, טכניקת מפתח המאפשרת אצווה יעילה. לאחר מכן נציג אסטרטגיות מעשיות ליצירת אצוות ובחירת גודל אצווה מתאים. לבסוף, נעבור על פרטי ההטמעה ונציג את שיפורי הביצועים שהושגו: הפחתה של 50% בזמן השהיית ההסקה ב-GPU – למרות השימוש בפחות GPUs פי 3.

הסרת ריפוד מאפשרת אצווה יעילה

בהתחשב בדפוסי תעבורת השאילתות, עולה רעיון פשוט: האם נוכל לקבץ אותן לאצוות כדי לשפר את יעילות ההסקה? הסרת ריפוד, הנתמכת במנועי הסקה כמו vLLM ו-SGLang, הופכת אצווה יעילה לאפשרית.

רוב מנועי ההסקה מקבלים בקשות בצורה (B, S), כאשר B הוא מספר הרצף באצווה, ו-S הוא אורך הרצף המרבי. יש לרפד את הרצפים לאורך המקסימלי כדי ליישר את הטנסורים. אולם, לנוחות הזו יש מחיר: אסימוני ריפוד אינם תורמים דבר אך עדיין צורכים רוחב פס של זיכרון ומחשוב, כך שההשהיה גדלה לפי B × S במקום לפי ספירת האסימונים בפועל. בעת הגשת נפחים גדולים של בקשות קצרות, הדבר מבזבז משאבי מחשוב רבים ועלול לנפח את השהיית הזנב (tail latency). הסרת ריפוד ועיבוד באורך משתנה פותרים זאת על ידי שרשור כל הרצפים הפעילים ל"רצף-על" אחד באורך T = Σtoken_count_i, כאשר token_count_i הוא מספר האסימונים ברצף i. מנועי הסקה כמו vLLM ו-SGLang יכולים לעבד רצף משולב זה. מסכות קשב (Attention masks) ומדדי מיקום מבטיחים שכל רצף יתייחס רק לאסימונים שלו. כתוצאה מכך, זמן ההסקה תואם כעת ל-T במקום ל-B × S, ובכך מתאים את עבודת ה-GPU למה שחשוב באמת.

הצעה: אצווה מבוססת ספירת אסימונים

ב-Voyage AI הצענו ובנינו פתרון Batching מבוסס ספירת אסימונים, המקבץ שאילתות (בקשות קצרות) לפי ספירת האסימונים הכוללת באצווה (Σtoken_count_i), ולא לפי ספירת בקשות כוללת או חלונות זמן שרירותיים.

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

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

מהו גודל האצווה האופטימלי?

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

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

ביצוע Batching לבקשות קצרות יכול להעביר את ההסקה מהאזור המוגבל בזיכרון לאזור המוגבל במחשוב. אם נבחר את נקודת הרוויה ב-Figure 3 כגודל האצווה (ספירת האסימונים הכוללת באצווה), ניתן לאזן ולייעל את ההשהיה ואת ה-throughput/MFU.

תכנון תור: הפעלת Batching מבוסס ספירת אסימונים

Batching מבוסס ספירת אסימונים דורש מערכת נתונים שעושה יותר מאשר מסירת FIFO פשוטה. המערכת צריכה לצרף לכל בקשה הערכת token_count, לבחון בקשות ממתינות, ולאחר מכן לתבוע אטומית תת-קבוצה שסך האסימונים שלה מתאים לגודל האצווה האופטימלי (Σtoken_count_i ≤ optimal_batch_size). ללא פרימיטיבים אלה, אנו עלולים למלא את ה-GPU בחסר – מה שמבזבז תקורה קבועה – או למלא אותו ביתר ולהקפיץ את השהיית הזנב.

ברוקרים למטרות כלליות כמו RabbitMQ ו-Kafka מצוינים לעמידות, הפצה (fan-out) ומשלוח, אך כפתורי ה-Batching שלהם מבוססים על ספירת הודעות/בייטים, לא אסימונים. מנגנון ה-prefetch ב-RabbitMQ מבוסס על ספירת בקשות, וההודעות נדחפות לצרכנים, כך שאין דרך יעילה לבחון ולבצע Batching לפי Σtoken_count_i. Kafka מבצעת Batching לפי בייטים/הודעות בתוך מחיצה; מכיוון שספירת האסימונים משתנה בהתאם לטקסט ול-tokenizer, אין דרך יעילה לבצע Batching לפי Σtoken_count_i.

לכן, קיימים שני נתיבים מעשיים להפעלת Batching מבוסס ספירת אסימונים. הראשון הוא הצבת אגרגטור קל-משקל לפני Kafka/RabbitMQ, אשר צורך אצוות לפי ספירת אסימונים ושולח אותן לשרתי המודל. השני הוא שימוש בחנות נתונים שתומכת באופן טבעי בבחינה מהירה (peek) וב-Batching מותנה – למשל, Redis עם סקריפט Lua. ביישום שלנו אנו משתמשים ב-Redis, מכיוון שהוא מאפשר לנו "לשלוף אטומית עד גודל האצווה האופטימלי" ולהגדיר TTL לכל פריט במסגרת קריאת סקריפט Lua בודדת. לא משנה מה נבחר, הדרישה המהותית זהה: התור חייב לאפשר למערכת שלנו לראות פריטים ממתינים מרובים, לקבץ לפי Σtoken_count_i, ולתבוע אותם אטומית כדי לשמור על ניצול יציב והשהיה צפויה.

המערכת שלנו מעמידה כל בקשת שאילתת הטמעה ברשימה ⁦Redis⁩ בתור:

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

תוצאות

ערכנו ניסוי ב-Production על הגשת המודל Voyage-3-Large, והשווינו את הצינור (pipeline) החדש שלנו (Batching של שאילתות + vLLM) מול הצינור הישן שלנו (ללא Batching + Hugging Face Inference). ראינו ירידה של 50% בהשהיית ההסקה של ה-GPU – למרות השימוש בפחות GPUs פי 3.

העברנו בהדרגה 7+ מודלים לפתרון ה-Batching של השאילתות לעיל, וראינו את התוצאות הבאות (שים לב שתוצאות אלו מבוססות על ההטמעות הספציפיות שלנו לצינורות ה"חדשים" וה"ישנים", ואינן ניתנות להכללה בהכרח):

• vLLM מקטין את זמן ההסקה של ה-GPU בעד ~20 מילי-שניות עבור רוב המודלים שלנו.

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

• התפוקה משתפרת בעד פי 8 באמצעות Batching מבוסס ספירת אסימונים.

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

• זמן השהיית P90 מקצה לקצה יציב יותר במהלך פרצי תנועה, אפילו עם פחות GPUs.

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

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

תודה רבה ל⁦Tengyu Ma⁩, ⁦Andrew Whitaker⁩, ⁦Ken Hong⁩, ⁦Angel Lim⁩, ו-⁦Andrew Gaut⁩ על דיונים מועילים רבים לאורך הדרך, ול-⁦Akshat Vig⁩, ⁦Murat Demirbas⁩, ו-⁦Stan Halka⁩ על ביקורות ומשוב.

#embeddings#inference-optimization#llm-infra#voyage-ai
קרא במקור