Perhatian Kilat: Merevolusi Efisiensi Transformer

</pre>
import torch

<p>def perhatian_standar(Q, K, V):
# Q, K, V bentuk: (batch_size, seq_len, d_model)
d_k = K.size(-1)
scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k))
attention_weights = torch.softmax(scores, dim=-1)
return torch.matmul(attention_weights, V)</p>

Implementasi ini, meskipun sederhana, menderita ketidakefisienan yang disebutkan di atas. Tensor scores, yang memiliki bentuk (batch_size, seq_len, seq_len), dapat menjadi sangat besar untuk urutan panjang.

Memasuki Perhatian Kilat

Perhatian Kilat, diperkenalkan oleh Tri Dao dan rekan dalam makalah mereka tahun 2022, adalah pendekatan untuk menghitung perhatian yang secara dramatis mengurangi penggunaan memori dan meningkatkan efisiensi komputasi. Ide kunci di balik Perhatian Kilat adalah:

1. Pengubinan: Memecah matriks perhatian besar menjadi ubin yang lebih kecil yang sesuai dengan SRAM on-chip yang cepat.
2. Penghitungan Ulang: Alih-alih menyimpan matriks perhatian seluruhnya, hitung kembali bagian-bagian tertentu selama proses balik.
3. Implementasi yang Sadar IO: Optimalkan algoritma untuk meminimalkan pergerakan data antara tingkat hierarki memori GPU yang berbeda.

Algoritma Perhatian Kilat

Inti dari Perhatian Kilat adalah menghitung kembali mekanisme perhatian. Alih-alih menghitung seluruh matriks perhatian sekaligus, ia memprosesnya dalam blok, memanfaatkan hierarki memori GPU modern.

Berikut adalah gambaran tingkat tinggi dari algoritma:

1. Input: Matriks Q, K, V di HBM (High Bandwidth Memory) dan SRAM on-chip dengan ukuran M.
2. Ukuran blok dihitung berdasarkan SRAM yang tersedia.
3. Inisialisasi matriks output O, dan vektor bantu l dan m.
4. Algoritma membagi matriks input menjadi blok untuk sesuai dengan SRAM.
5. Dua loop bersarang memproses blok-blok ini:
   • Loop luar memuat blok K dan V
   • Loop dalam memuat blok Q dan melakukan komputasi
6. Komputasi on-chip termasuk perkalian matriks, softmax, dan perhitungan output.
7. Hasil ditulis kembali ke HBM setelah memproses setiap blok.

Komputasi blok-blok ini memungkinkan Perhatian Kilat untuk mempertahankan jejak memori yang jauh lebih kecil sambil masih menghitung perhatian yang tepat.

Matematika di Balik Perhatian Kilat

Kunci untuk membuat Perhatian Kilat bekerja adalah trik matematika yang memungkinkan kita untuk menghitung softmax secara blok-blok. Makalah ini memperkenalkan dua rumus kunci:

1. Penguraian Softmax:
   softmax(x) = exp(x - m) / Σexp(x - m)

   di mana m adalah nilai maksimum di x.

2. Penggabungan Softmax:
   softmax(x ∪ y) = softmax(softmax(x) * e^(m_x - m), softmax(y) * e^(m_y - m))

   di mana m = max(m_x, m_y)

Rumus-rumus ini memungkinkan Perhatian Kilat untuk menghitung hasil softmax parsial untuk setiap blok dan kemudian menggabungkannya dengan benar untuk mendapatkan hasil akhir.

Detail Implementasi

Mari kita menyelami implementasi sederhana dari Perhatian Kilat untuk menggambarkan konsep intinya:

import torch

<p>def perhatian_kilat(Q, K, V, block_size=256):
batch_size, seq_len, d_model = Q.shape</p>

<p># Inisialisasi output dan statistik berjalan
O = torch.zeros_like(Q)
L = torch.zeros((batch_size, seq_len, 1))
M = torch.full((batch_size, seq_len, 1), float(&#039;-inf&#039;))</p>

<p>for i in range(0, seq_len, block_size):
Q_block = Q[:, i:i+block_size, :]</p>

<p>for j in range(0, seq_len, block_size):
K_block = K[:, j:j+block_size, :]
V_block = V[:, j:j+block_size, :]</p>

<p># Hitung skor perhatian untuk blok ini
S_block = torch.matmul(Q_block, K_block.transpose(-2, -1)) / (d_model ** 0.5)</p>

<p># Perbarui maksimum berjalan
M_new = torch.maximum(M[:, i:i+block_size], S_block.max(dim=-1, keepdim=True).values)</p>

<p># Hitung eksponensial
exp_S = torch.exp(S_block - M_new)
exp_M_diff = torch.exp(M[:, i:i+block_size] - M_new)</p>

<p># Perbarui jumlah berjalan
L_new = exp_M_diff * L[:, i:i+block_size] + exp_S.sum(dim=-1, keepdim=True)</p>

<p># Hitung output untuk blok ini
O[:, i:i+block_size] = (
exp_M_diff * O[:, i:i+block_size] +
torch.matmul(exp_S, V_block)
) / L_new</p>

<p># Perbarui statistik berjalan
L[:, i:i+block_size] = L_new
M[:, i:i+block_size] = M_new</p>

return O

Implementasi ini, meskipun disederhanakan, menangkap esensi dari Perhatian Kilat. Ia memproses input dalam blok, mempertahankan statistik berjalan (M dan L) untuk menghitung softmax secara blok-blok.

Dampak Perhatian Kilat

Pengenalan Perhatian Kilat telah memiliki dampak yang mendalam pada bidang pembelajaran mesin, terutama untuk model bahasa besar dan aplikasi konteks panjang. Beberapa manfaat kunci termasuk:

1. Penggunaan Memori yang Berkurang: Perhatian Kilat mengurangi kompleksitas memori dari O(N^2) menjadi O(N), di mana N adalah panjang urutan. Ini memungkinkan pemrosesan urutan yang jauh lebih panjang dengan perangkat keras yang sama.
2. Kecepatan yang Ditingkatkan: Dengan meminimalkan pergerakan data dan memanfaatkan kemampuan komputasi GPU, Perhatian Kilat mencapai percepatan yang signifikan. Penulis melaporkan hingga 3x lebih cepat dalam pelatihan untuk GPT-2 dibandingkan dengan implementasi standar.
3. Perhitungan yang Tepat: Tidak seperti beberapa teknik optimasi perhatian lainnya, Perhatian Kilat menghitung perhatian yang tepat, bukan perkiraan.
4. Skalabilitas: Jejak memori yang berkurang memungkinkan skala ke urutan yang jauh lebih panjang, potensial hingga jutaan token.

Dampak Dunia Nyata

Dampak Perhatian Kilat meluas ke luar penelitian akademis. Ia telah dengan cepat diadopsi dalam banyak perpustakaan dan model pembelajaran mesin populer:

• Transformers Hugging Face: Perpustakaan Transformers populer telah mengintegrasikan Perhatian Kilat, memungkinkan pengguna untuk dengan mudah memanfaatkan manfaatnya.
• GPT-4 dan Setelahnya: Meskipun tidak dikonfirmasi, ada spekulasi bahwa model bahasa lanjutan seperti GPT-4 mungkin menggunakan teknik serupa dengan Perhatian Kilat untuk menangani konteks panjang.
• Model Konteks Panjang: Perhatian Kilat telah memungkinkan generasi baru model yang dapat menangani konteks yang sangat panjang, seperti model yang dapat memproses seluruh buku atau video panjang.

PerhatianKilat: Pengembangan Terbaru

Perhatian Standar Vs Perhatian Kilat

PerhatianKilat-2

Membangun pada kesuksesan Perhatian Kilat asli, tim yang sama memperkenalkan PerhatianKilat-2 pada tahun 2023. Versi yang diperbarui ini membawa beberapa perbaikan:

1. Optimasi Lebih Lanjut: PerhatianKilat-2 mencapai utilitas GPU yang lebih baik, mencapai hingga 70% puncak FLOPS teoritis pada GPU A100.
2. Proses Balik yang Diperbarui: Proses balik dioptimalkan untuk menjadi hampir secepat proses maju, menghasilkan percepatan signifikan dalam pelatihan.
3. Dukungan untuk Varian Perhatian yang Berbeda: PerhatianKilat-2 memperluas dukungan untuk berbagai varian perhatian, termasuk perhatian query-grup dan perhatian multi-query.

PerhatianKilat-3

Dirilis pada tahun 2024, PerhatianKilat-3 mewakili kemajuan terbaru dalam seri penelitian ini. Ia memperkenalkan beberapa teknik baru untuk lebih meningkatkan kinerja:

1. Perhitungan Asinkron: Memanfaatkan sifat asinkron dari instruksi GPU baru untuk mengoverlap komputasi yang berbeda.
2. Dukungan FP8: Menggunakan komputasi presisi rendah FP8 untuk pemrosesan yang lebih cepat.
3. Pemrosesan Tidak Kohesen: Teknik untuk mengurangi kesalahan kuantisasi saat menggunakan format presisi rendah.

Berikut adalah contoh sederhana tentang bagaimana PerhatianKilat-3 mungkin memanfaatkan komputasi asinkron:

import torch
from torch.cuda.amp import autocast

<p>def perhatian_kilat_3(Q, K, V, block_size=256):
with autocast(dtype=torch.float8): # Menggunakan FP8 untuk komputasi
# ... (serupa dengan implementasi sebelumnya)</p>

<p># Contoh komputasi asinkron
with torch.cuda.stream(torch.cuda.Stream()):
# Hitung GEMM secara asinkron
S_block = torch.matmul(Q_block, K_block.transpose(-2, -1)) / (d_model ** 0.5)</p>

<p># Sementara itu, di aliran default:
# Siapkan untuk komputasi softmax</p>

<p># Sinkronkan aliran
torch.cuda.synchronize()</p>

<p># Lanjutkan dengan softmax dan perhitungan output
# ...</p>

return O

Potongan kode ini menggambarkan bagaimana PerhatianKilat-3 mungkin memanfaatkan komputasi asinkron dan presisi FP8. Perlu diingat bahwa ini adalah contoh sederhana dan implementasi sebenarnya akan jauh lebih kompleks dan spesifik perangkat keras.

Mengimplementasikan Perhatian Kilat di Proyek Anda

Jika Anda tertarik untuk memanfaatkan Perhatian Kilat di proyek Anda sendiri, Anda memiliki beberapa pilihan:

1. Gunakan Perpustakaan yang Ada: Banyak perpustakaan populer seperti Hugging Face Transformers sekarang telah mengintegrasikan Perhatian Kilat. Memperbarui ke versi terbaru dan mengaktifkan bendera yang sesuai mungkin sudah cukup.
2. Implementasi Kustom: Untuk kontrol yang lebih besar atau kasus penggunaan khusus, Anda mungkin ingin mengimplementasikan Perhatian Kilat sendiri. Perpustakaan xformers menyediakan implementasi referensi yang baik.
3. Optimasi Spesifik Perangkat Keras: Jika Anda bekerja dengan perangkat keras tertentu (misalnya, GPU NVIDIA H100), Anda mungkin ingin memanfaatkan fitur spesifik perangkat keras untuk kinerja maksimal.

Berikut adalah contoh tentang bagaimana Anda mungkin menggunakan Perhatian Kilat dengan perpustakaan Hugging Face Transformers:

from transformers import AutoModel, AutoConfig

<p># Aktifkan Perhatian Kilat
config = AutoConfig.from_pretrained(&quot;bert-base-uncased&quot;)
config.use_flash_attention = True</p>

<p># Muat model dengan Perhatian Kilat
model = AutoModel.from_pretrained(&quot;bert-base-uncased&quot;, config=config)</p>

<p># Gunakan model seperti biasa
# ...

Tantangan dan Arah Masa Depan

Meskipun Perhatian Kilat telah membuat kemajuan signifikan dalam meningkatkan efisiensi mekanisme perhatian, masih ada tantangan dan area untuk penelitian masa depan:

1. Spesifisitas Perangkat Keras: Implementasi saat ini sering dioptimalkan untuk arsitektur GPU tertentu. Menggeneralisasi optimasi ini di seluruh perangkat keras yang berbeda tetap menjadi tantangan.
2. Integrasi dengan Teknik Lain: Menggabungkan Perhatian Kilat dengan teknik optimasi lain seperti pemangkasan, kuantisasi, dan kompresi model adalah area penelitian yang aktif.
3. Perluasan ke Domain Lain: Meskipun Perhatian Kilat menunjukkan kesuksesan besar dalam NLP, memperluas manfaatnya ke domain lain seperti penglihatan komputer dan model multimodal adalah upaya yang sedang berlangsung.
4. Pemahaman Teoritis: Memperdalam pemahaman teoritis tentang mengapa Perhatian Kilat bekerja dengan baik bisa mengarah pada optimasi yang lebih kuat.

Kesimpulan

Dengan memanfaatkan hierarki memori GPU dan menggunakan trik matematika, Perhatian Kilat mencapai peningkatan yang signifikan dalam kecepatan dan penggunaan memori tanpa mengorbankan akurasi.

Seperti yang kita eksplorasi dalam artikel ini, dampak Perhatian Kilat meluas jauh melampaui teknik optimasi sederhana. Ia telah memungkinkan pengembangan model yang lebih kuat dan efisien.