Embeddings ומסדי וקטורים: איך מכונה "מבינה" משמעות

בואו נטוס גבוה. אני רוצה שתעצרו רגע ותחשבו על משהו מטורף: כשאתם מקלידים בגוגל "מקום רומנטי לארוחת ערב", המנוע מבין אתכם גם אם בתפריט של המסעדה כתוב "אווירה אינטימית לזוגות" — בלי אף מילה משותפת. איך מכונה, שבסך הכל יודעת לחבר ולכפול מספרים, "מבינה" שֶׁשתי דרכים שונות לגמרי לכתוב דבר מתכוונות לאותו דבר? התשובה היא הטכנולוגיה שמתחת לכל ה-AI שאתם מכירים היום: Embeddings (אמבדינגס) ומסדי וקטורים (Vector Databases). בואו נפרק את זה לגמרי, פירור אחר פירור.

הבעיה: מחשב לא מבין מילים, הוא מבין מספרים

נתחיל מהיסוד. מעבד (CPU — היחידה במחשב שמבצעת את החישובים) הוא מכונת חישוב — הוא יודע לעשות פעולות על מספרים. המילה "חתול" עבורו היא רק רצף של תווים, בדיוק כמו "xj4#". אין לו שום מושג ש"חתול" קרוב ל"כלב" (שניהם חיות מחמד) ורחוק מ"מקרר". כדי שמכונה תוכל "להבין" משמעות, אנחנו חייבים קודם להפוך כל מילה, משפט או מסמך למספרים — ולא לסתם מספר אחד, אלא לרשימה ארוכה של מספרים שמקודדת את המשמעות. הרשימה הזאת נקראת וקטור (vector) — שזו בסך הכל מילה מפוצצת ל"רשימה של מספרים", למשל ‎[0.12, -0.88, 0.4, ...]‎.

האינטואיציה: מפה של משמעות

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

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

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

איך מודדים "קרבה"? המתמטיקה הקטנה והיפה

אם כל פיסת טקסט היא נקודה במרחב, "כמה שני טקסטים דומים" הופך לשאלה גאומטרית פשוטה: כמה הנקודות שלהם קרובות. הדרך הנפוצה נקראת Cosine Similarity (דמיון קוסינוס — קוסינוס הוא פונקציה מתמטיקה שמודדת את הזווית בין שני כיוונים). אל תיבהלו מהשם. האינטואיציה: דמיינו חץ שיוצא מהמרכז לכל נקודה. אם שני חצים מצביעים לאותו כיוון — הטקסטים דומים. אם הם מאונכים (זווית של 90 מעלות ביניהם) — לא קשורים. אם הם הפוכים — מנוגדים. הציון נע בין 1 (זהה לחלוטין) ל‎-1‎ (הפוך לגמרי). למה כיוון ולא מרחק? כי הכיוון תופס את אופי המשמעות בלי להיות מוטה מאורך הטקסט — משפט קצר ומשפט ארוך שמדברים על אותו דבר יצביעו לאותו כיוון, גם אם אחד "רחוק" יותר מהמרכז. זהו — זאת כל ה"הבנה". לא קסם, גאומטריה.

איפה נכנס מסד הווקטורים?

נניח שיש לכם מיליון מסמכים — כל מאמרי הבלוג שלכם, כל מסמכי החברה. הפכתם כל אחד ל-embedding. עכשיו מגיע משתמש עם שאלה, ואתם רוצים למצוא את 5 המסמכים הכי רלוונטיים. הדרך התמימה: להפוך את השאלה ל-embedding, ואז להשוות אותה לכל מיליון הווקטורים אחד-אחד. זה יעבוד — אבל יהיה איטי בטירוף. פה נכנס מסד הווקטורים: מסד נתונים שתוכנן במיוחד לאחסן מיליוני וקטורים ולמצוא את ה"שכנים הקרובים" של וקטור-שאילתה (הווקטור של השאלה שאנחנו מחפשים לפיה) במילי-שניות, בלי לסרוק את כולם.

איך הוא עושה את זה כל כך מהר? באמצעות אינדקס חכם שנקרא ANN (ראשי תיבות של Approximate Nearest Neighbor — "שכן-קרוב-מקורב"; אינדקס הוא מבנה עזר שמסדר את המידע מראש כדי שאפשר יהיה למצוא דברים בלי לעבור על הכל). במקום לבדוק כל וקטור, הוא בונה מראש מבנה שמקבץ וקטורים קרובים יחד (קצת כמו אינדקס בסוף ספר שמפנה אותך ישר לעמוד הנכון במקום לדפדף בכל הספר). המילה "מקורב" חשובה: הוא מוותר על דיוק מושלם תאורטי תמורת מהירות עצומה — כלומר הוא עלול לפספס פעם בכמה זמן את השכן הכי-הכי קרוב ולהביא את השני-הכי-קרוב, אבל בפועל התוצאות כמעט תמיד מצוינות. שמות שתפגשו: Pinecone, Weaviate, Qdrant, Chroma, ו-pgvector (תוסף ל-PostgreSQL הרגיל — מסד הנתונים הקלאסי שכבר מריצים בהרבה חברות). כולם עושים את אותו דבר בלב: שמור וקטורים, מצא שכנים מהר.

הדבר הכי שימושי שתבנו עם זה: RAG

עכשיו לחיבור שעושה את כל זה שווה זהב. מודל שפה כמו Claude לא יודע על המסמכים הפרטיים שלכם, והוא יכול "להמציא" תשובות שנשמעות בטוחות אבל שגויות (תופעה שנקראת הזיה / hallucination). הפתרון נקרא RAG — ראשי תיבות של Retrieval-Augmented Generation, "יצירה מועשרת באחזור". במילים פשוטות: לפני שאתם שואלים את המודל, אתם קודם שולפים מהמסד את קטעי הטקסט הרלוונטיים לשאלה, ומדביקים אותם לפרומפט (ההוראה הטקסטואלית שאתם שולחים למודל) — כך המודל עונה על בסיס המקורות האמיתיים שלכם, לא מהדמיון שלו.

דוגמה קונקרטית שתריצו עכשיו (Python)

בלי ערפול — הנה מה שקורה מתחת. הקוד הזה בשפת Python, ומשתמש בספרייה של OpenAI כדי להמיר טקסט ל-embedding ולמדוד דמיון:

from openai import OpenAI
client = OpenAI()

def embed(text):
    r = client.embeddings.create(model="text-embedding-3-small", input=text)
    return r.data[0].embedding   # רשימה של 1,536 מספרים

import numpy as np  # ספריית מתמטיקה שמקלה על חישוב על רשימות מספרים
def cosine(a, b):
    a, b = np.array(a), np.array(b)
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))  # נוסחת דמיון הקוסינוס

v1 = embed("מקום רומנטי לארוחת ערב")
v2 = embed("מסעדה עם אווירה אינטימית לזוגות")
v3 = embed("איך מחליפים צמיג לרכב")

print(cosine(v1, v2))   # ~0.7 — קרוב מאוד, אף מילה משותפת
print(cosine(v1, v3))   # ~0.1 — רחוק, נושא אחר לגמרי

ראיתם? v1 ו-v2 לא חולקים אפילו מילה אחת, אבל הציון גבוה — כי המשמעות קרובה. זה כל הסיפור, וזה הבסיס לחיפוש סמנטי (חיפוש לפי משמעות במקום לפי מילים מדויקות), RAG, מנועי המלצות וזיכרון של סוכני AI.

הזיקוק: מה לקחת איתכם

מכונה לא מבינה מילים — היא ממירה אותן לembeddings, וקטורים שמקודדים משמעות כמיקום במרחב. "דמיון" הופך למרחק גאומטרי שמודדים ב-cosine similarity. מסד וקטורים שומר מיליוני וקטורים ומוצא שכנים קרובים במהירות עם אינדקס ANN. וכשמחברים הכל ל-RAG, מקבלים מודל שעונה על בסיס המידע שלכם, בלי להמציא. עכשיו, כשתבנו את הצ'אטבוט הבא שיודע הכל על העסק שלכם — תדעו בדיוק מה רוטט מתחת למכסה המנוע. בואו נטוס.