Silabus Pelajaran 107 dari 250 · Intuisi Neural-Net, LLM & Capstone AI
Intuisi Neural-Net, LLM & Capstone AI

Self-Attention dari Nol

Kamu sudah membangun neuron dan forward pass. Sekarang kamu akan membangun satu ide yang mengubah jaringan saraf biasa menjadi transformer dan, dari situ, menjadi LLM di balik setiap asisten chat: self-attention. Isinya segenggam perkalian matriks, dan kamu bisa mengerjakan semuanya di numpy.

Intuisinya

Bayangkan setiap kata dalam kalimat ingin mengumpulkan informasi dari kata-kata lain. Self-attention memberi setiap posisi tiga vektor:

  • Query (Q): apa yang dicari posisi ini.
  • Key (K): apa yang ditawarkan setiap posisi, dipakai untuk mencocokkan.
  • Value (V): informasi sebenarnya yang dibawa setiap posisi.

Sebuah posisi membandingkan query-nya dengan setiap key untuk memutuskan seberapa banyak ia mendengarkan setiap posisi lain, lalu mengambil campuran berbobot dari value dengan takaran itu. Cocok kuat -> bobot besar -> value itu menyumbang lebih banyak. Itulah seluruh mekanismenya: query memperhatikan key, dan jawabannya adalah campuran berbobot dari value.

Matematikanya: scaled dot-product attention

Skor kecocokan antara query dan key adalah hasil kali titik-nya (lebih besar kalau keduanya menunjuk ke arah yang sama). Tumpuk semua query menjadi matriks Q dan semua key menjadi K, dan semua skor sekaligus adalah Q @ K.T. Kita membagi dengan sqrt(d_k) (dimensi key) supaya skornya tidak meledak saat vektornya makin panjang:

scores = Q @ K.T / np.sqrt(d_k)

Kenapa harus dibagi? Hasil kali titik tumbuh seiring dimensi. Kalau d_k 64 dan isinya sekitar 1, skor mentahnya mendekati 64, dan angka sebesar itu mendorong softmax ke satu key saja dan meratakan gradiennya. Membagi dengan sqrt(d_k), di sini sqrt(64) = 8, menarik skornya kembali ke rentang yang wajar supaya attention tetap halus dan bisa dilatih. Di contoh kecil d_k = 1 yang kamu jalankan di bawah, pembaginya hanya 1, jadi kamu tidak akan melihat efeknya, tetapi pada ukuran model sungguhan ini sangat penting.

Setiap baris dari scores berisi skor satu query terhadap setiap key. Kita mengubah setiap baris menjadi bobot yang positif dan berjumlah 1 dengan softmax pada sumbu terakhir:

weights = softmax(scores, axis=-1)   # each row sums to 1

Softmax memangkatkan lalu menormalkan. Kalau dikerjakan secara naif, np.exp dari skor besar meluap menjadi inf dan bobotnya keluar sebagai nan. Perbaikannya adalah trik standar yang stabil secara numerik: kurangi nilai maksimum setiap baris sebelum memangkatkan. Secara matematis hasilnya tidak berubah (konstanta yang sama saling menghapus di atas dan di bawah), tetapi setiap pangkat tetap <= 0:

def softmax(x):
    x = x - x.max(axis=-1, keepdims=True)   # stability: largest exponent is now 0
    e = np.exp(x)
    return e / e.sum(axis=-1, keepdims=True)

Terakhir, keluaran setiap query adalah bobotnya yang diterapkan pada value, yaitu satu perkalian matriks lagi:

output = weights @ V

Kalau digabung, rumus terkenalnya hanyalah softmax(Q @ K.T / sqrt(d_k)) @ V. Kalau Q berukuran (n, d_k), K (m, d_k), dan V (m, d_v), maka weights berukuran (n, m) dan output (n, d_v): satu vektor keluaran per query, masing-masing campuran dari baris-baris value.

Inilah seluruh trik transformer

Transformer sungguhan tidak berhenti di satu perhitungan attention. Multi-head attention menjalankan beberapa sekaligus (setiap head mempelajari proyeksi Q, K, V-nya sendiri, jadi head yang berbeda memperhatikan hal yang berbeda) lalu menyambung hasilnya. Sebuah blok transformer kemudian menumpuk attention dengan jaringan feed-forward kecil dan koneksi residual, dan sebuah model menumpuk puluhan blok itu. Tetapi jantung yang berdetak di setiap blok itu persis fungsi yang akan kamu tulis: skor, softmax yang stabil, jumlah berbobot dari value. Bangun ini dan kamu memahami operasi inti yang diulang LLM ketika ia "memperhatikan" prompt.

Satu catatan jujur: di sini Q, K, dan V diberikan kepadamu sebagai array tetap. Di model sungguhan mereka tidak diberikan, mereka dihasilkan dengan mengalikan embedding setiap token dengan tiga matriks bobot yang dipelajari, W_q, W_k, dan W_v. Matriks-matriks itu, dan yang ada di setiap blok, persis yang disesuaikan pelatihan dengan gradient descent dari pelajaran sebelumnya. Jadi yang kamu bangun di sini adalah inti attention yang tetap dan sama di setiap transformer; pembelajarannya ada di proyeksi yang memberinya makan.

Tekan Run untuk melihat attention mengubah Q/K/V kecil menjadi keluaran dan mencetak matriks bobotnya, supaya kamu bisa membaca siapa memperhatikan siapa.

Giliranku

Implement scaled dot-product attention di numpy. Tulis attention(Q, K, V) yang mengembalikan tuple (output, weights). Hitung scores = Q @ K.T / np.sqrt(d_k) di mana d_k adalah dimensi terakhir dari Q; terapkan numerically stable softmax pada sumbu terakhir (kurangi nilai max tiap baris sebelum np.exp) untuk mendapatkan weights yang jumlah barisnya adalah 1; lalu output = weights @ V. Kembalikan output dulu, baru matriks weights. Lalu atur out, w = attention(Q, K, V) untuk array yang disediakan.

Ada masalah di pelajaran ini? Laporkan · Tanya tentang pelajaran ini

Latihan ini akan segera dibuka

Selesaikan pelajaran sebelumnya agar pelajaran ini terbuka. Seluruh kursus ini gratis, tidak butuh akun, dan kamu bisa baca pelajaran ini sekarang.