Q/K/V در transform در AI

حتماً. حالا که Tokenizer → Token ID → Embedding را فهمیدی، Q/K/V خیلی منطقی‌تر می‌شود.

بیاییم دقیقاً از همان‌جایی که بودیم ادامه بدهیم.

فرض کن جمله:

I love programming

بعد از Embedding داریم:

I           → [0.2, 0.5, 0.1, ...]
love        → [0.7, 0.1, 0.8, ...]
programming  → [0.4, 0.9, 0.3, ...]

این بردارها وارد Self-Attention می‌شوند.


Q/K/V برای چه هستند؟

هدف Self-Attention این است:

هر Token بفهمد برای فهم خودش، به کدام Tokenهای دیگر چقدر باید توجه کند.

مثلاً:

The cat drank the milk because it was thirsty.

وقتی مدل it را بررسی می‌کند، باید بفهمد:

it → cat

نه اینکه مثلاً:

it → milk

برای این کار Q/K/V ساخته می‌شوند.


مرحله اول: از Embedding سه چیز می‌سازیم

فرض کن Embedding مربوط به it این باشد:

it
↓
X
↓
[0.4, 0.7, 0.2, 0.9]

مدل سه ماتریس دارد:

WQ
WK
WV

و از X سه بردار می‌سازد:

             Embedding
                 X
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
      WQ        WK        WV
       ↓         ↓         ↓
       Q         K         V

یعنی:

Q = X × WQ
K = X × WK
V = X × WV

اما چرا سه بردار؟

این قسمت را با یک مثال انسانی ببین.

فرض کن وارد یک کتابخانه شده‌ای.

Query

تو یک سؤال داری:

«من دنبال کتابی درباره برنامه‌نویسی هستم.»

این می‌شود Query.


Key

هر کتاب یک برچسب دارد:

کتاب A → تاریخ
کتاب B → برنامه‌نویسی
کتاب C → آشپزی

این می‌شود Key.

تو Query خودت را با Key کتاب‌ها مقایسه می‌کنی.

Query
"برنامه‌نویسی"

       ↓

Key A → تاریخ          ❌
Key B → برنامه‌نویسی   ✅
Key C → آشپزی          ❌

Value

حالا که کتاب مناسب را پیدا کردی، محتوای کتاب را می‌گیری.

این می‌شود Value.

پس:

Query = دنبال چه چیزی هستم؟

Key = آیا من چیزی هستم که تو دنبالش می‌گردی؟

Value = اگر مرتبط بودم، چه اطلاعاتی به تو بدهم؟


حالا برگردیم به جمله

The cat drank the milk because it was thirsty.

فرض کنیم داریم it را بررسی می‌کنیم.

برای it یک Query داریم:

Q(it)

و برای تمام Tokenها Key داریم:

K(The)
K(cat)
K(drank)
K(the)
K(milk)
K(because)
K(it)
K(was)
K(thirsty)

حالا Query مربوط به it با تمام Keyها مقایسه می‌شود.

مثلاً به‌صورت فرضی:

Q(it) × K(The)      → 0.05
Q(it) × K(cat)      → 0.91
Q(it) × K(drank)    → 0.12
Q(it) × K(milk)     → 0.18
Q(it) × K(thirsty)  → 0.42

پس مدل می‌گوید:

cat       ← ارتباط زیاد
thirsty   ← ارتباط متوسط
The       ← ارتباط کم
milk      ← ارتباط کم

این اعداد تبدیل به Attention Weight می‌شوند

بعد از پردازش این امتیازها، چیزی شبیه این داریم:

The       0.02
cat       0.65
drank     0.03
the       0.01
milk      0.08
because   0.02
it        0.04
was       0.03
thirsty   0.12

جمعشان تقریباً:

1.0

یعنی:

برای ساختن representation جدید it، اطلاعات cat اهمیت بیشتری دارد.


حالا Value وارد می‌شود

ما برای cat یک Value هم داریم:

V(cat)

برای milk:

V(milk)

برای thirsty:

V(thirsty)

و…

حالا مدل این Valueها را با وزن‌های Attention ترکیب می‌کند:

Output(it)
=
0.02 × V(The)
+
0.65 × V(cat)
+
0.03 × V(drank)
+
...
+
0.12 × V(thirsty)

پس اطلاعات cat سهم بیشتری در Output مربوط به it دارد.


این یعنی Self-Attention

در یک تصویر:

                 it
                 │
                 │ Query
                 ↓
        ┌──────────────────┐
        │ Compare with     │
        │ all Keys         │
        └──────────────────┘
                 │
                 ↓
          Attention Weights
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
     cat        milk     thirsty
     0.65       0.08       0.12
       │         │           │
       ↓         ↓           ↓
     V(cat)    V(milk)    V(thirsty)
       └─────────┼───────────┘
                 ↓
              Output

حالا یک نکته خیلی مهم

Q/K/V خودشان چیزی نیستند که انسان به مدل داده باشد.

مدل این‌ها را از Embedding می‌سازد:

Embedding
    │
    ├── × WQ → Q
    │
    ├── × WK → K
    │
    └── × WV → V

و WQ, WK, WV Weightهای قابل یادگیری هستند.

یعنی در Training، مدل یاد می‌گیرد:

چگونه از Embedding یک Query مناسب بسازم؟

چگونه یک Key مناسب بسازم؟

چه Valueای را منتقل کنم؟


و اینجا ارتباط خیلی زیبایی شکل می‌گیرد

تا الان مسیر را این‌طور یاد گرفته‌ای:

Text
 ↓
Tokenizer
 ↓
Token IDs
 ↓
Embedding
 ↓
Q / K / V
 ↓
Attention

و اگر بخواهیم دقیق‌تر کنیم:

             Embedding X
                  │
        ┌─────────┼─────────┐
        ↓         ↓         ↓
      X×WQ      X×WK      X×WV
        ↓         ↓         ↓
        Q         K         V
        │         │
        └── Q×K ──┘
             ↓
       Attention Score
             ↓
          Softmax
             ↓
      Attention Weights
             ↓
       Weights × V
             ↓
           Output

نکته کلیدی:
Q و K مشخص می‌کنند «به چه کسی توجه کنم؟» و V مشخص می‌کند «از آن چه اطلاعاتی بگیرم؟»

اگر موافقی، قدم بعدی را می‌توانیم با اعداد واقعی و یک مثال ۳ کلمه‌ای حساب کنیم؛ مثلاً دقیقاً محاسبه کنیم Q × Kᵀ چطور انجام می‌شود و ببینیم چرا cat امتیاز بیشتری از milk می‌گیرد.

حتماً. حالا بریم واقعاً Q/K/V را با عدد حساب کنیم. اینجا معمولاً مفهوم Transformer جا می‌افتد.

فرض کنیم جمله خیلی ساده باشد:

"cat eats fish"

بعد از Tokenizer و Embedding، فرض می‌کنیم Embedding هر Token این باشد:

cat  → [1, 0]
eats → [0, 1]
fish → [1, 1]

این اعداد کاملاً فرضی و کوچک هستند تا محاسبه را راحت ببینیم.


1. از Embedding، Q/K/V می‌سازیم

فرض کنیم برای ساده‌سازی:

WQ = [[1, 0],
      [0, 1]]

WK = [[1, 0],
      [0, 1]]

WV = [[1, 0],
      [0, 1]]

در این مثال خاص، این ماتریس‌ها Identity هستند، بنابراین:

Q = X
K = X
V = X

پس:

cat  → Q=[1,0]   K=[1,0]   V=[1,0]
eats → Q=[0,1]   K=[0,1]   V=[0,1]
fish → Q=[1,1]   K=[1,1]   V=[1,1]

در مدل واقعی، WQ/WK/WV این‌قدر ساده نیستند و در Training یاد گرفته می‌شوند.


2. حالا Attention می‌خواهد ببیند cat به چه چیزی توجه کند

Query مربوط به cat:

Q(cat) = [1, 0]

حالا آن را با Key همه Tokenها مقایسه می‌کنیم.

با cat

Q(cat) · K(cat)

[1,0] · [1,0]

= 1×1 + 0×0
= 1

با eats

Q(cat) · K(eats)

[1,0] · [0,1]

= 1×0 + 0×1
= 0

با fish

Q(cat) · K(fish)

[1,0] · [1,1]

= 1×1 + 0×1
= 1

پس امتیازهای خام:

cat   → 1
eats  → 0
fish  → 1

یعنی از نظر این مثال:

cat ←── توجه زیاد ──→ cat
cat ←── توجه کم  ──→ eats
cat ←── توجه زیاد ──→ fish

3. چرا Dot Product؟

این:

Q · K

در واقع یک روش برای اندازه‌گیری شباهت/هم‌جهتی دو بردار است.

اگر:

Q = [1,0]
K = [1,0]

آنگاه:

Q · K = 1

ولی اگر:

Q = [1,0]
K = [0,1]

داریم:

Q · K = 0

پس هرچه دو بردار در جهت مشابه‌تری باشند، معمولاً امتیاز بیشتری می‌گیریم.


4. اما هنوز Attention Weight نداریم

فعلاً داریم:

[1, 0, 1]

اینها فقط Score هستند.

Transformer معمولاً آنها را با softmax تبدیل می‌کند:

[1, 0, 1]
   ↓
Softmax
   ↓
[0.422, 0.155, 0.422]

یعنی تقریباً:

cat   → 42.2%
eats  → 15.5%
fish  → 42.2%

حالا می‌توانیم بگوییم cat برای ساخت representation خودش:

  • حدود 42٪ به خودش
  • حدود 16٪ به eats
  • حدود 42٪ به fish

توجه می‌کند.


5. حالا Value وارد می‌شود

Valueها:

V(cat)  = [1,0]
V(eats) = [0,1]
V(fish) = [1,1]

حالا آنها را با Attention Weightها ترکیب می‌کنیم:

Output(cat)
=
0.422 × [1,0]
+
0.155 × [0,1]
+
0.422 × [1,1]

محاسبه کنیم:

0.422 × [1,0]
= [0.422, 0]

0.155 × [0,1]
= [0, 0.155]

0.422 × [1,1]
= [0.422, 0.422]

جمع:

[0.422, 0]
+
[0, 0.155]
+
[0.422, 0.422]

=

[0.844, 0.577]

پس:

cat
↓
[0.844, 0.577]

این representation جدید cat بعد از Attention است.


حالا نکته فوق‌العاده مهم

قبل از Attention داشتیم:

cat → [1,0]

بعد از Attention:

cat → [0.844, 0.577]

چرا تغییر کرد؟

چون cat اطلاعاتی از Tokenهای دیگر گرفته است.

این دقیقاً یکی از کارهای اصلی Self-Attention است:

Representation هر Token را با توجه به Context آن به‌روزرسانی می‌کند.


حالا برگردیم به مثال واقعی‌تر

این جمله را ببین:

The cat drank the milk because it was thirsty.

وقتی مدل it را پردازش می‌کند، می‌تواند چیزی شبیه این بسازد:

                 it
                 │
          Query(it)
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
      cat       milk     thirsty
      Key       Key        Key
       │         │          │
       ↓         ↓          ↓
     Score      Score      Score
      0.91       0.18       0.42
       │
       ↓
    Softmax
       │
       ↓
 Attention Weights
       │
       ├──── 0.65 × V(cat)
       ├──── 0.08 × V(milk)
       └──── 0.12 × V(thirsty)
                    ↓
                 Output(it)

در نتیجه representation it اطلاعاتی از cat دریافت می‌کند.


اما یک سؤال خیلی مهم

احتمالاً الان می‌پرسی:

خب از کجا مدل می‌فهمد که Q مربوط به it باید با K مربوط به cat امتیاز بالایی بدهد؟

اینجا برمی‌گردیم به چیزی که قبلاً گفتیم:

Q = X × WQ
K = X × WK

و:

WQ
WK
WV

خودشان Weightهای قابل یادگیری هستند.

در ابتدا ممکن است تصادفی باشند:

WQ → مقادیر تصادفی
WK → مقادیر تصادفی
WV → مقادیر تصادفی

ولی در Training:

Prediction
   ↓
Loss
   ↓
Backpropagation
   ↓
Gradient
   ↓
Update WQ/WK/WV
   ↓
دوباره Prediction

این کار میلیون‌ها یا میلیاردها بار تکرار می‌شود.

در نتیجه مدل کم‌کم یاد می‌گیرد که:

Q(it) · K(cat) → امتیاز مناسب

و در موقعیت‌های مختلف روابط معنایی و نحوی را بهتر مدل کند.


یک تصویر ذهنی نهایی

کل Attention را فعلاً این‌طور در ذهنت نگه دار:

                 Embeddings
                     │
                     ▼
              ┌─────────────┐
              │   Q K V     │
              └─────────────┘
                     │
                     ▼
              Q × Kᵀ
                     │
                     ▼
              "به چه کسی
               توجه کنم؟"
                     │
                     ▼
                  Softmax
                     │
                     ▼
             Attention Weights
                     │
                     ▼
                  × V
                     │
                     ▼
            Contextual Output

و قلب ماجرا همین است:

Q و K تعیین می‌کنند «چقدر به هر Token توجه کنم»؛ V مشخص می‌کند «چه اطلاعاتی از آن Token دریافت کنم».

بعد از این، دو مفهوم خیلی مهم باقی می‌ماند که Transformer را کامل‌تر می‌کنند:

Multi-Head Attention → چرا چند Attention همزمان داریم؟

و

Feed Forward Network → بعد از اینکه Tokenها اطلاعات همدیگر را گرفتند، مدل با این اطلاعات چه کار می‌کند؟

دیدگاه‌ها

دیدگاهتان را بنویسید

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *