Attention and Transformer

Created onDibuat padaAugust 26, 202626 Agustus 2026

Last updated onTerakhir diperbaruiMay 6, 20266 Mei 2026

15 min read15 menit baca

IDattentiontransformerRNNdeep-learningdata-science

ContributorsKontributor

Razi Rachman Widyadhana - @zirachw

Attention adalah mekanisme yang membuat model dapat memilih bagian input yang paling relevan ketika menghasilkan output. Dalam model sekuens, attention muncul sebagai jawaban atas kelemahan encoder-decoder RNN yang memadatkan seluruh input ke satu context vector tetap.

#Link to this headingIntuisi Attention

Pada encoder-decoder tanpa attention, seluruh informasi input disimpan dalam satu vektor konteks. Untuk sekuens panjang, satu vektor ini menjadi bottleneck. Decoder harus menghasilkan seluruh output hanya dari ringkasan tunggal tersebut.

Bahdanau, Cho, dan Bengio mengusulkan agar decoder tidak membuang semua hidden state encoder. Semua hidden state digunakan kembali, lalu decoder belajar memberi bobot lebih besar pada state yang relevan untuk output saat ini. Figure 1 pada paper Bahdanau menggambarkan decoder yang menghasilkan target word $y_t$ dengan memperhatikan semua anotasi encoder $h_1, h_2, \ldots, h_T$ .

Figure 1 Bahdanau attention, decoder menghasilkan target word yt dengan attention terhadap h1 sampai hT dari source sentence x1 sampai xT

Secara intuitif, attention melakukan tiga hal.

Menilai relevansi setiap hidden state encoder terhadap kebutuhan decoder.
Mengubah skor relevansi menjadi bobot attention.
Membentuk context vector sebagai kombinasi berbobot dari semua hidden state encoder.

Jika sebuah kata target bergantung kuat pada kata input tertentu, bobot attention pada posisi input tersebut akan lebih besar.

#Link to this headingMany-to-One dengan Attention

Pada RNN many-to-one biasa, output sering hanya bergantung pada hidden state terakhir. Attention mengubah hal ini dengan memberi akses ke semua hidden state masa lalu. Model tidak hanya memakai $h^{(T)}$ , tetapi membentuk konteks dari $h^{(1)}, h^{(2)}, \ldots, h^{(T)}$ .

Slide many to one with attention, bobot alpha memberi perhatian pada hidden state masa lalu untuk membentuk context vector

Misalkan terdapat $T$ timestep. Nilai attention untuk timestep $j$ dilambangkan dengan $\alpha_j$ . Context vector dibentuk sebagai berikut.

c = \sum_{j=1}^{T} \alpha_j h^{(j)}

Bobot attention biasanya dinormalisasi sehingga jumlahnya sama dengan 1.

\sum_{j=1}^{T} \alpha_j = 1

Dengan begitu, $c$ dapat dibaca sebagai ringkasan adaptif dari seluruh sekuens. Kata adaptif penting karena ringkasan ini dipelajari dari data, bukan ditentukan manual.

#Link to this headingJumlah Parameter

Contoh pada slide menggunakan RNN many-to-one dengan 2 hidden unit, 1 unit dense, dan 20 timestep.

Tanpa attention, jumlah parameternya adalah sebagai berikut.

\text{parameter} = (n_{\text{input}} + n_{\text{hidden}} + 1)n_{\text{hidden}} + (n_{\text{hidden}} + 1)n_{\text{output}}

Dengan $n_{\text{input}} = 1$ , $n_{\text{hidden}} = 2$ , dan $n_{\text{output}} = 1$ , diperoleh nilai berikut.

(1 + 2 + 1)2 + (2 + 1)1 = 8 + 3 = 11

Dengan attention sederhana pada implementasi tertentu, terdapat parameter tambahan berupa bobot attention untuk setiap timestep dan bias attention. Pada contoh slide, tambahan parameternya adalah 20 bobot attention dan 2 bias.

#Link to this headingForward Propagation dengan Attention

RNN tetap menghitung hidden state seperti biasa.

h^{(j)} = f_h(W_{xh}x^{(j)} + W_{hh}h^{(j-1)} + b_{xh})

Perbedaannya muncul pada output. Tanpa attention, model many-to-one biasanya memakai hidden state terakhir.

y = f_y(W_{hy}h^{(T)} + b_{hy})

Dengan attention, model memakai context vector.

y = f_y(W_{hy}c + b_{hy})

Karena $c$ adalah kombinasi dari semua hidden state, output dapat memanfaatkan informasi yang muncul jauh sebelum timestep terakhir.

Slide many to one attention forward propagation dengan Wxh Whh Why dan context vector

#Link to this headingMany-to-Many dengan Attention

Pada encoder-decoder many-to-many, attention biasanya dihitung ulang pada setiap timestep decoder. Artinya, decoder dapat melihat bagian input yang berbeda ketika menghasilkan token output yang berbeda.

Jika encoder menghasilkan $N$ hidden state dan decoder menghasilkan $T$ token, bobot attention dapat ditulis sebagai $\alpha_{tj}$ , yaitu bobot attention dari decoder pada waktu $t$ terhadap encoder pada posisi $j$ .

c_t = \sum_{j=1}^{N} \alpha_{tj} h_j

Subskrip $t$ pada $c_t$ menunjukkan bahwa konteks berubah untuk setiap langkah decoder. Ini menjadi perbedaan penting dengan encoder-decoder lama yang hanya memiliki satu konteks tetap.

Slide attention many to one versus many to many, jumlah parameter attention dan context vector per timestep decoder

#Link to this headingBahdanau dan Luong Attention

Attention pada RNN umumnya memiliki tiga tahap. Pertama, model menghitung skor kecocokan antara decoder dan setiap hidden state encoder. Kedua, skor tersebut dinormalisasi menjadi bobot attention. Ketiga, bobot tersebut dipakai untuk membentuk context vector.

#Link to this headingNotasi

Catatan ini memakai konvensi yang sesuai dengan gambar kuliah sebagai berikut.

Simbol	Arti	Dipakai untuk
$h_j$	Hidden state encoder pada posisi input ke- $j$	Sumber informasi yang akan diperhatikan decoder
$s_t$	Hidden state decoder pada timestep ke- $t$	Memori internal decoder
$\tilde{s}_t$	Attentional decoder state pada Luong	Gabungan antara $c_t$ dan $s_t$ sebelum output
$y_{t-1}$	Token output sebelumnya, dipakai sebagai input decoder	Biasanya $y_0 = \langle s \rangle$ sebagai start token
$y_t$	Output yang diprediksi pada timestep ke- $t$	Token atau kelas yang keluar dari decoder
$e_{tj}$	Skor attention antara decoder timestep $t$ dan encoder posisi $j$	Nilai mentah sebelum softmax
$\alpha_{tj}$	Bobot attention terhadap encoder posisi $j$ pada timestep $t$	Menentukan seberapa besar $h_j$ dipakai
$c_t$	Context vector pada timestep decoder $t$	Ringkasan encoder yang berubah untuk setiap output
$f$	Fungsi aktivasi atau update state decoder	Menghasilkan state decoder berikutnya
$g$	Fungsi output, misalnya softmax atau linear	Menghasilkan prediksi $y_t$
$p(y_t \mid y_{<t}, x)$	Probabilitas output saat ini	Dipakai untuk memprediksi token berikutnya

Simbol bobot seperti $W_a$ , $U_a$ , dan $v_a$ adalah parameter yang dipelajari model.

Parameter	Arti	Bentuk peran
$W_a$	Bobot attention untuk sisi decoder	Mengubah informasi decoder ke ruang skor attention
$U_a$	Bobot attention untuk sisi encoder	Mengubah hidden state encoder ke ruang skor attention
$v_a$	Vektor proyeksi attention	Mengubah hasil $\tanh$ menjadi satu skor skalar
$W_y$	Bobot dari token input decoder $y_{t-1}$	Menghubungkan token input decoder ke state decoder
$W_h$	Bobot recurrent decoder	Menghubungkan hidden state decoder sebelumnya ke state berikutnya
$W_c$	Bobot context	Menghubungkan context vector ke state atau output decoder
$W_o$	Bobot output	Mengubah state decoder menjadi prediksi output

Perlu dibedakan antara memprediksi output dan melangkah ke timestep berikutnya. Prediksi output berarti menghitung $y_t$ dari state decoder saat ini. Melangkah ke timestep berikutnya berarti output sebelumnya, misalnya $y_t$ , menjadi masukan untuk menghitung state berikutnya.

Secara umum, alur satu timestep decoder adalah sebagai berikut.

Pakai informasi decoder saat ini atau sebelumnya untuk menghitung skor attention terhadap setiap $h_j$ .
Ubah skor menjadi bobot $\alpha_{tj}$ dengan softmax.
Bentuk context vector $c_t$ .
Hitung state decoder dan output.
Gunakan output tersebut sebagai masukan timestep berikutnya.

#Link to this headingBahdanau Attention

Bahdanau attention disebut additive attention karena skor attention dihitung dengan menjumlahkan transformasi decoder dan encoder sebelum dilewatkan ke $\tanh$ .

Skor dihitung dengan fungsi align.

e_{tj} = \text{align}(s_{t-1}, h_j)

Salah satu bentuk yang umum dipakai adalah sebagai berikut.

e_{tj} = v_a^T \tanh(W_a s_{t-1} + U_a h_j)

Bagian yang membuatnya disebut additive adalah penjumlahan berikut.

W_a s_{t-1} + U_a h_j

Bobot attention diperoleh dengan softmax terhadap semua skor encoder.

\alpha_{tj} = \frac{\exp(e_{tj})} {\sum_{k=1}^{N}\exp(e_{tk})}

Kemudian konteks dibentuk dari semua hidden state encoder.

c_t = \sum_{j=1}^{N} \alpha_{tj}h_j

Setelah context vector tersedia, state decoder diperbarui dengan memasukkan $c_t$ secara langsung ke dalam pembaruan state. Ini menjadi ciri khas Bahdanau karena skor attention dihitung menggunakan state sebelumnya $s_{t-1}$ , sehingga konteks dapat ikut membentuk state terbaru.

s_t = f(W_y y_{t-1} + W_h s_{t-1} + W_c c_t + b_s)

Output diprediksi dari state decoder yang sudah mengandung konteks.

y_t = g(W_o s_t + b_o)

Jadi pada Bahdanau, urutannya adalah: hitung skor memakai $s_{t-1}$ , bentuk $c_t$ , update $s_t$ , lalu prediksi $y_t$ . Setelah itu, $y_t$ dipakai sebagai input decoder pada timestep berikutnya.

#Link to this headingLuong Attention

Luong attention memakai ide yang mirip, tetapi state decoder $s_t$ biasanya dihitung terlebih dahulu tanpa context vector. Setelah itu, attention dihitung menggunakan $s_t$ .

s_t = f(W_y y_{t-1} + W_h s_{t-1} + b_s)

Fungsi skornya sering ditulis sebagai $\text{score}(s_t, h_j)$ .

\alpha_{tj} = \frac{\exp(\text{score}(s_t,h_j))} {\sum_{k=1}^{N}\exp(\text{score}(s_t,h_k))}

Beberapa varian skor Luong yang umum adalah dot, general, dan concat.

\text{score}(s_t,h_j) = \begin{cases} s_t^T h_j & \text{dot} \\ s_t^T W_a h_j & \text{general} \\ v_a^T \tanh(W_a\,\text{concat}(s_t,h_j)) & \text{concat} \end{cases}

Varian dot dan general disebut multiplicative karena skor dihitung lewat perkalian vektor atau matriks.

c_t = \sum_{j=1}^{N} \alpha_{tj}h_j

Setelah $c_t$ terbentuk, Luong menggabungkan context vector dan state decoder menjadi attentional state $\tilde{s}_t$ .

\tilde{s}_t = \tanh(W_c \operatorname{concat}(c_t, s_t))

Output diprediksi dari attentional state.

y_t = g(W_o \tilde{s}_t + b_o)

Jadi pada Luong, urutannya adalah: update $s_t$ dahulu, hitung skor memakai $s_t$ , bentuk $c_t$ , gabungkan $c_t$ dan $s_t$ , lalu prediksi $y_t$ . Setelah itu, $y_t$ dipakai sebagai input decoder pada timestep berikutnya.

#Link to this headingPerbandingan Alur

Tabel berikut merangkum alur satu timestep secara end-to-end. Perhatikan bahwa $y_{t-1}$ adalah token input decoder, sedangkan $s_t$ adalah hidden state decoder.

Urutan	Bahdanau	Luong
1. Input decoder	Menerima $y_{t-1}$ dan state lama $s_{t-1}$	Menerima $y_{t-1}$ dan state lama $s_{t-1}$
2. State untuk skor	Skor attention memakai state lama $s_{t-1}$	State baru dihitung dulu dengan $s_t = f(W_y y_{t-1} + W_h s_{t-1} + b_s)$
3. Bentuk skor	$e_{tj} = v_a^T \tanh(W_a s_{t-1} + U_a h_j)$	$e_{tj} = s_t^T h_j$ atau $e_{tj} = s_t^T W_a h_j$
4. Jenis skor	Additive karena ada $W_a s_{t-1} + U_a h_j$ sebelum $\tanh$	Multiplicative untuk dot dan general karena memakai perkalian $s_t$ dengan $h_j$
5. Bobot attention	$\alpha_{tj} = \text{softmax}(e_{tj})$	$\alpha_{tj} = \text{softmax}(e_{tj})$
6. Context vector	$c_t = \sum_j \alpha_{tj}h_j$	$c_t = \sum_j \alpha_{tj}h_j$
7. State yang dipakai output	Context masuk saat update state, yaitu $s_t = f(W_y y_{t-1} + W_h s_{t-1} + W_c c_t + b_s)$	Context digabung setelah $s_t$ terbentuk, yaitu $\tilde{s}_t = \tanh(W_c \operatorname{concat}(c_t, s_t))$
8. Prediksi output	$y_t = g(W_o s_t + b_o)$	$y_t = g(W_o \tilde{s}_t + b_o)$
9. Lanjut timestep	$y_t$ dipakai sebagai input $y_{t-1}$ pada timestep berikutnya	$y_t$ dipakai sebagai input $y_{t-1}$ pada timestep berikutnya

Jika $\alpha_{tj}$ sudah tersedia, bagian skor sudah tidak perlu dihitung. Namun perbedaan cara memasukkan context ke decoder dan penentuan $y_t$ masih berlaku: Bahdanau menghitung $y_t$ dari $s_t$ , sedangkan Luong menghitung $y_t$ dari $\tilde{s}_t$ .

#Link to this headingOutput dan Timestep

Prediksi output dan perpindahan timestep sering tertukar, padahal keduanya berbeda.

Proses	Makna	Contoh
Prediksi output	Menghasilkan token pada timestep sekarang	$y_t = g(W_o s_t + b_o)$
Menaikkan timestep	Memakai output sekarang sebagai input langkah berikutnya	$y_t$ dipakai sebagai $y_{t-1}$ pada timestep berikutnya
Attention	Memilih bagian encoder yang relevan untuk output saat ini	$c_t = \sum_j \alpha_{tj}h_j$

Contoh pada bentuk seperti soal Bagian 3 adalah sebagai berikut.

Timestep	Input decoder	Context attention	State decoder	Output
Awal	Belum ada output sebelumnya	Context tetap dari encoder dapat menjadi $s_0 = c$	$s_0 = c$	Belum ada $y$
$t=1$	$y_0 = \langle s \rangle$	Jika ada attention, $c_1^{att} = \alpha_{1,1}e_1 + \alpha_{1,2}e_2 + \alpha_{1,3}e_3$	$s_1 = f(W_y y_0 + W_h s_0 + W_c c_1^{att} + b_s)$	$y_1 = g(W_o s_1 + b_o)$
$t=2$	$y_1$	Jika ada attention, $c_2^{att} = \alpha_{2,1}e_1 + \alpha_{2,2}e_2 + \alpha_{2,3}e_3$	$s_2 = f(W_y y_1 + W_h s_1 + W_c c_2^{att} + b_s)$	$y_2 = g(W_o s_2 + b_o)$

Dengan kata lain, attention membantu decoder menentukan informasi input mana yang penting untuk memprediksi $y_t$ . Setelah $y_t$ diprediksi, decoder bergerak ke timestep berikutnya dan memakai output sebelumnya sebagai salah satu masukan.

Slide rumus Bahdanau attention, Luong attention, dan transisi menuju self attention Transformer

#Link to this headingDari Attention ke Transformer

Attention awalnya dipakai sebagai komponen tambahan pada RNN encoder-decoder. Transformer mengambil langkah yang lebih radikal. Arsitektur ini menghapus unit rekuren dan konvolusi, lalu menggantinya dengan self-attention dan jaringan feed-forward sederhana.

Perubahan ini penting karena pemrosesan paralel membuat pelatihan pada korpus yang sangat besar menjadi jauh lebih efisien. Selain itu, self-attention memberi jalur langsung antarposisi token sehingga dependensi panjang lebih mudah dimodelkan dibandingkan RNN biasa.

Slide vanilla RNN encoder decoder with attention versus Transformer, pemrosesan sekuensial dibanding paralel

#Link to this headingDot Product Self-Attention

Pada attention RNN, query biasanya berasal dari decoder dan key serta value berasal dari encoder. Pada self-attention, query, key, dan value berasal dari input yang sama, tetapi melalui transformasi linear yang berbeda.

Untuk setiap token input $x_m$ , model membentuk tiga vektor berikut.

q_m = W_Q x_m

k_m = W_K x_m

v_m = W_V x_m

Query digunakan untuk bertanya, key digunakan untuk mengukur kecocokan, dan value adalah informasi yang akan digabungkan.

Skor attention antara token $n$ dan token $m$ dihitung dengan dot product.

\text{score}(x_m,x_n) = k_m^Tq_n

Skor tersebut dinormalisasi dengan softmax.

a(x_m,x_n) = \frac{\exp(k_m^Tq_n)} {\sum_{m'=1}^{N}\exp(k_{m'}^Tq_n)}

Output self-attention untuk posisi $n$ adalah kombinasi berbobot dari semua value.

\text{sa}_n[x_1,\ldots,x_N] = \sum_{m=1}^{N} a(x_m,x_n)v_m

Slide Transformer dot product self attention, value query dan key dibentuk dari input yang sama

#Link to this headingScaled Dot Product Attention

Transformer memakai scaled dot product attention. Jika query, key, dan value dikemas dalam matriks $Q$ , $K$ , dan $V$ , attention dihitung dengan rumus berikut.

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

Faktor $\sqrt{d_k}$ digunakan agar nilai dot product tidak tumbuh terlalu besar ketika dimensi key besar. Tanpa skala ini, softmax dapat menjadi terlalu tajam sehingga gradien lebih sulit mengalir.

Pada beberapa konvensi slide, formula ditulis dengan susunan matriks $K^TQ$ karena token disimpan sebagai kolom. Intinya tetap sama. Query dibandingkan dengan key, hasilnya dinormalisasi, lalu bobot tersebut dipakai untuk menggabungkan value.

Slide scaled dot product self attention dalam bentuk matriks Q K V

#Link to this headingMulti-Head Attention

Satu attention head hanya belajar satu cara memandang hubungan antartoken. Transformer memakai beberapa head agar model dapat mempelajari beberapa pola relasi sekaligus.

Setiap head menghitung attention dengan proyeksi linear yang berbeda.

\text{head}_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)

Hasil semua head digabungkan, lalu diproyeksikan kembali.

\text{MultiHead}(Q,K,V) = \text{Concat}(\text{head}_1,\ldots,\text{head}_h)W^O

Dalam kalimat "the animal did not cross the street because it was tired", satu head dapat fokus pada "the animal" ketika memaknai "it", sedangkan head lain dapat fokus pada "tired". Representasi akhir token memadukan informasi dari beberapa pola perhatian.

Slide interpretasi multi head attention, beberapa head fokus pada kata yang berbeda

#Link to this headingPositional Encoding

Karena Transformer tidak memproses token secara rekuren, urutan token tidak otomatis masuk ke model. Posisi token harus ditambahkan melalui positional encoding.

Representasi input Transformer biasanya berupa penjumlahan antara token embedding dan positional encoding.

z_i = e_i + p_i

Di sini $e_i$ adalah embedding token ke- $i$ , sedangkan $p_i$ adalah representasi posisi token ke- $i$ . Dengan cara ini, self-attention tetap mengetahui urutan token meskipun semua token diproses paralel.

Slide positional encoding pada Transformer

#Link to this headingArsitektur Transformer

Arsitektur Transformer asli terdiri atas encoder stack dan decoder stack. Encoder menerima token input, sedangkan decoder menghasilkan token output secara autoregresif.

Slide arsitektur Transformer dari Vaswani, encoder stack decoder stack scaled dot product attention multi head attention dan feed forward

Encoder layer memiliki dua sublapisan utama.

Multi-head self-attention.
Feed-forward network posisi demi posisi.

Decoder layer memiliki tiga sublapisan utama.

Masked multi-head self-attention agar decoder tidak melihat token masa depan.
Multi-head attention terhadap output encoder.
Feed-forward network posisi demi posisi.

Setiap sublapisan dilengkapi koneksi residual dan normalisasi, yang sering ditulis sebagai Add and Norm. Koneksi residual membantu gradien mengalir, sedangkan normalisasi membuat pelatihan lebih stabil.

#Link to this headingOutput Transformer

Output decoder stack masih berupa vektor representasi. Agar dapat menjadi kata, vektor ini diproyeksikan oleh linear layer ke ukuran kosakata. Hasil proyeksi disebut logits.

Jika kosakata berisi 10.000 kata, maka vektor logits memiliki 10.000 komponen. Softmax mengubah logits menjadi distribusi probabilitas. Kata dengan probabilitas tertinggi dipilih sebagai output pada timestep tersebut.

p(y_t \mid y_{<t}, x) = \text{softmax}(W_o z_t + b_o)

Slide linear layer dan softmax mengubah output decoder Transformer menjadi probabilitas token kosakata

#Link to this headingRingkasan

Attention menyelesaikan masalah bottleneck pada encoder-decoder dengan membuat konteks yang bergantung pada kebutuhan output. Bahdanau dan Luong attention masih berada dalam keluarga RNN encoder-decoder. Transformer mengembangkan ide attention lebih jauh dengan self-attention penuh, pemrosesan paralel, multi-head attention, dan positional encoding.

Perubahan besar dari RNN ke Transformer adalah sumber memorinya. RNN membawa informasi melalui state berurutan, sedangkan Transformer menghubungkan semua token melalui attention. Karena itu, Transformer menjadi dasar banyak model modern untuk bahasa, visi, dan data multimodal.

Recurrent Neural Network

Reinforcement Learning

Backlinks

IF3270 - Machine Learning