איך מודל יודע מה חשוב?

"Attention is all you need" המאמר משנת 2017 שעליו בנויים כל ה-LLMs היום. בפוסט הזה נצלול לרעיון מאפס, מהאינטואיציה הראשונית ועד הנוסחה המלאה, כולל הניואנסים המתמטיים שכמעט אף אחד לא מסביר.

6 דקות קריאה 24 במאי 2026

#attention
#transformers
#LLM

שי אביבי

כל מה שאתם מכירים מ-LLM, ChatGPT, Claude, Gemini, Llama, מסתמך על רעיון אחד שפורסם ב-2017. הרעיון הזה כל כך פשוט שאחרי שתבינו אותו, תשאלו את עצמכם איך אף אחד לא חשב עליו קודם.

תרגיל קטן לפני שמתחילים

קראו את המשפט הבא:

“המורה צעקה על התלמידה כי היא הייתה עצבנית.”

מי הייתה עצבנית? המורה.

עכשיו נחליף מילה אחת בלבד, בסוף המשפט:

“המורה צעקה על התלמידה כי היא התחצפה.”

מי התחצפה? התלמידה.

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

אז איך בדיוק המוח שלנו ידע לעשות את זה?

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

זה בדיוק מה ש-attention עושה. וזה הרעיון המרכזי שמאחורי כל LLM שאתם מכירים.

אבל קודם, איך מחשב בכלל “מבין” מילים?

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

הפתרון נקרא embedding. כל מילה הופכת לרשימת מספרים, או בשפה קצת יותר מקצועית - “וקטור” במרחב רב-ממדי. החוכמה היא שמילים דומות מקבלות וקטורים שמצביעים לכיוון דומה.

תארו לעצמכם מרחב דו-ממדי (האמיתי הוא ממדים רבים, אבל לצורך האינטואיציה):

מרחב embedding

לחצו על מילה כדי להוסיף או להסיר אותה מהמרחב.

“שמח” ו”מאושר” יהיו קרובים אחד לשני. “שמח” ו”עצוב” יהיו רחוקים, אבל על אותו ציר (רגש). “שמח” ו”מכונית” יהיו במקומות לגמרי אחרים.

זה הקסם של embeddings: הם הופכים יחסים סמנטיים ליחסים גאומטריים. ועל הגאומטריה הזאת אפשר לעשות חשבון.

בחזרה לבעיה שאנחנו רוצים לפתור

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

נתון משפט עם מילים $w_1, w_2, ..., w_n$ , ולכל מילה יש וקטור אמבדינג (מה שראינו בפסקה הקודמת) $x_i$ . ואנחנו רוצים לחשב לכל מילה ייצוג חדש $y_i$ , וקטור, שלוקח בחשבון את כל שאר המילים, אבל עם משקל שונה לכל אחת.

במילים אחרות:

y_i = \sum_{j=1}^{n} \alpha_{i,j} \cdot x_j

כאשר $\alpha_{i,j}$ הוא המשקל שמילה $i$ נותנת למילה $j$ .

ממוצע משוקלל

המורה33%

התלמידה33%

עצבנית33%

המשקלים שולטים על המיקום של y. נסו לשנות אותם.

הכל מסתכם בשאלה אחת: איך מחשבים את $\alpha_{i,j}$ ?

כלי ראשון - Dot Product או “מד דמיון”

אם יש לי שני וקטורים, איך אני יכול למדוד עד כמה הם דומים? יש כלי פשוט ומדהים מעולמות האלגברה לינארית שנקרא dot product (מכפלה סקלרית):

a \cdot b = \sum_i a_i b_i

והרעיון של dot product הוא גאומטרי:

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

מכפלה סקלרית

טווח חופשי (גרירה)

a · b

1.25

זווית

0°

לחצו על כפתור. אותו כיוון = חיובי. ניצב = אפס. הפוך = שלילי.

אז אולי הפתרון הוא פשוט: $\alpha_{i,j} = x_i \cdot x_j$ ? כלומר, “נבדוק כמה המילה דומה לי, ואם היא דומה ממש היא תקבל יותר משקל”?

זה רעיון לא רע, אבל יש לו בעיה.

למה דמיון פשוט לא מספיק

בחזרה למשפט שלנו: “המורה צעקה על התלמידה כי היא הייתה עצבנית.”

המילה “היא” צריכה להסתכל על “המורה” כדי להבין מי האובייקט שמרגיש עצבנות. אבל באותו משפט, אם נשאל “מה גרם לצעקה?”, היא הייתה צריכה לתת משקל גם ל”עצבנית”, המילה שמסבירה את הסיבה.

אותה מילה צריכה להיות מסוגלת לשאול שאלות שונות בהקשרים שונים. ו-dot product פשוט בין embeddings לא מאפשר את הגמישות הזאת.

צריך משהו חכם יותר.

הטריק החדש - Q, K, V

והנה הטריק החדש, במקום להשתמש ב-embedding ישירות, נלמד שלוש הטלות(ניחן לחשוב על זה כלמידת “וקטורים” חדשים) של כל מילה.

לכל מילה $i$ נחשב:

Q_i = W_Q \cdot x_i \quad \text{(Query)}

K_i = W_K \cdot x_i \quad \text{(Key)}

V_i = W_V \cdot x_i \quad \text{(Value)}

כאשר $W_Q, W_K, W_V$ הן מטריצות נלמדות (אלו הפרמטרים שהמודל מאמן).

Q, K, V

בחרו מילה מהמשפט

המילה "היא" משחקת שלושה תפקידים שונים בו-זמנית. כל תפקיד הוא וקטור אחר, נלמד מאותו x דרך מטריצה אחרת. הנה מה שכל אחד מהם "אומר":

כל ריבוע = מספר אחד בוקטור. גובה המילוי = גודל המספר.

Query(שואלת)

"מחפשת שם עצם נקבה שכבר הוזכר במשפט"

Key(מציעה)

"אני כינוי גוף יחיד, מין נקבה"

Value(תוכן)

"הפנייה לסובייקט קודם"

ההסברים בעברית הם פרשנות אנושית. במציאות, מה ש-Q/K/V "אומרים" נלמד מהנתונים ולא ניתן לפענוח ישיר במילים.

כל מילה הופכת לשלושה וקטורים שונים, אחד לכל תפקיד.

האנלוגיה הכי טובה היא חיפוש בגוגל:

כשאתם מקלידים שאילתת חיפוש, זה ה-Query
לכל אתר באינדקס יש תיאור / מטא-טאגים, זה ה-Key
התוכן של האתר עצמו, זה ה-Value

גוגל מוצא התאמה בין השאילתה שלכם (Q) לתיאורי האתרים (K), ומחזיר את התוכן (V) של ההתאמות הטובות ביותר.

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

הקסם פה הוא ש-Q, K, V הן הטלות שונות של אותה מילה. המודל יכול ללמוד ש”היא” שואלת שאלות מסוג אחד דרך $W_Q$ , ומציעה מידע מסוג אחר דרך $W_K$ . ההפרדה הזאת היא מה שהופך את המנגנון לכל כך גמיש.

חישוב המשקלים

עכשיו, בשביל לחשב כמה משקל מילה $i$ נותנת למילה $j$ , נשווה את ה-Query של $i$ לכל ה-Keys:

\text{score}(i, j) = Q_i \cdot K_j

מעולה. יש לנו ציון! אבל יש בעיה, הציון הזה יכול להיות כל מספר, חיובי, שלילי, ענק. אנחנו רוצים שהמשקלים יהיו “אמיתיים” ואנחנו צריכים לדרוש ש:

כולם יהיו חיוביים
מסתכמים ל-1 (כדי שזה יהיה ממוצע משוקלל)

הפתרון המתבקש: softmax.

softmax - מציונים להסתברויות

softmax לוקח רשימה של מספרים והופך אותם להתפלגות הסתברות:

\text{softmax}(z_i) = \frac{e^{z_i}}{\sum_k e^{z_k}}

זה לא קסם, זה פשוט מאוד. שני שלבים:

מעריך: $e^{z_i}$ הופך כל מספר לחיובי (וגם מגדיל הבדלים)
נירמול: מחלקים בסכום כך שהכל יסתכם ל-1

Softmax

z₀1.5

z₁2.0

z₂3.0

p₀

14.0%

p₁

23.1%

p₂

62.9%

גררו את הסליידרים. הפסים מראים את ההסתברויות שיוצאות (סכומן 1).

אז המשקל הסופי שלנו:

\alpha_{i,j} = \text{softmax}_j(Q_i \cdot K_j) = \frac{e^{Q_i \cdot K_j}}{\sum_k e^{Q_i \cdot K_k}}

הניואנס המתמטי שכולם מדלגים עליו

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

הנוסחה האמיתית של attention היא לא $Q K^T$ , אלא:

\frac{Q K^T}{\sqrt{d_k}}

מאיפה הגיע ה- $\sqrt{d_k}$ ? ( $d_k$ הוא הממד של וקטורי ה-Query וה-Key.)

הנה האינטואיציה: נניח ש- $Q$ ו- $K$ הם וקטורים אקראיים שכל רכיב שלהם נדגם מהתפלגות עם שונות 1. ה-dot product שלהם הוא סכום של $d_k$ מכפלות, ולכן השונות שלו היא $d_k$ , וסטיית התקן היא $\sqrt{d_k}$ .

מה זה אומר? כשהוקטורים ארוכים, ה-dot products הופכים גדולים יותר בממוצע.

ולמה זה רע? כי softmax היא רגישה מאוד לגודל הקלט. אם תכניסו ל-softmax את [1, 2, 3] תקבלו פיזור יחסית רך. אבל אם תכניסו [10, 20, 30], כמעט כל המסה תהיה על האיבר השלישי.

Softmax עם סקלה

z₀1.5

z₁2.0

z₂3.0

מכפיל את כל הקלטים לפני שהם נכנסים ל-softmax.

scale×1.0

p₀

14.0%

p₁

23.1%

p₂

62.9%

גררו את הסקאלה למעלה. ראו איך softmax מתחדדת, פס אחד לוקח כמעט את כל המסה.

החלוקה ב- $\sqrt{d_k}$ מנרמלת את הציונים חזרה לקנה מידה הגיוני. זה שומר על softmax “רכה” מספיק כדי שגרדיאנטים יזרמו באימון.

זה ניואנס קטן, אבל בלעדיו המודל לא היה מתאמן בכלל.

הנוסחה המלאה

עכשיו אפשר להציג את הנוסחה המפורסמת, וכל איבר בה יהיה הגיוני:

\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V

$Q K^T$ - ציוני דמיון בין כל זוג מילים (Query מול Key)

$\sqrt{d_k}$ - נירמול לשמירה על softmax רכה

$\text{softmax}$ - המרת ציונים למשקלים שמסתכמים ל-1

כפל ב- $V$ - שילוב המידע (Values) לפי המשקלים

וזהו! הנוסחה כבר לא מאיימת, היא סיכום של כל מה שדיברנו עד עכשיו.

דוגמה למשקלי Attention במשפט

נחזור לדוגמה: “המורה צעקה על התלמידה כי היא הייתה עצבנית.”

Attention demo

המורה צעקה על התלמידה כי היא הייתה עצבנית

לחצו על מילה ימנית כדי לבודד את המשקלים שלה.

לחצו על מילה בצד ימין כדי לראות אילו מילים היא מקבלת מהן הכי הרבה משקל.

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

מימוש ב-PyTorch

עכשיו אפשר לראות כמה זה פשוט בקוד:

import torch
import torch.nn.functional as F
import math

def attention(Q, K, V):
    """
    Q, K, V: tensors of shape (batch, seq_len, d_k)
    Returns: tensor of shape (batch, seq_len, d_k)
    """
    d_k = Q.size(-1)

    # 1. Score matrix: QK^T / sqrt(d_k)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

    # 2. Apply softmax to get attention weights
    weights = F.softmax(scores, dim=-1)

    # 3. Multiply by V to get weighted values
    output = torch.matmul(weights, V)

    return output, weights


class SelfAttention(torch.nn.Module):
    def __init__(self, d_model, d_k):
        super().__init__()
        self.W_Q = torch.nn.Linear(d_model, d_k)
        self.W_K = torch.nn.Linear(d_model, d_k)
        self.W_V = torch.nn.Linear(d_model, d_k)

    def forward(self, x):
        # x: (batch, seq_len, d_model)
        Q = self.W_Q(x)  # (batch, seq_len, d_k)
        K = self.W_K(x)  # (batch, seq_len, d_k)
        V = self.W_V(x)  # (batch, seq_len, d_k)

        return attention(Q, K, V)

זה הכל. כל ה-LLMs שאתם מכירים בנויים מהבלוקים האלה, מוערמים זה על זה.

מה הלאה?

ראינו attention עם “ראש” אחד, $W_Q, W_K, W_V$ אחד. אבל במציאות, מודלים משתמשים ב-Multi-Head Attention, מספר מקבילי של ראשי attention, כל אחד עם זוויות מבט אחרות על אותו משפט.

למה ראש אחד לא מספיק? למה כל ראש לומד “תפקיד” שונה? ואיך זה מתחבר לארכיטקטורת ה-Transformer המלאה?

על זה נדבר בפוסטים הבאים.

אם הפוסט הזה עזר לכם, שתפו אותו עם מישהו שעדיין חושב ש-ChatGPT ‘מבין’ אותו.