AttentionGrid
0.0.22
AttentionGrid dibawa kepada Anda oleh Agora, kami adalah organisasi penelitian AI multi-modal open source baru yang ditujukan untuk memajukan kemanusiaan.
Bergabunglah dengan kami di sini untuk berkontribusi pada proyek ini atau menerima dukungan!
AttentionGrid adalah kerangka kerja mutakhir yang dirancang untuk mendemokratisasi penggabungan mekanisme perhatian canggih ke dalam model AI. Didukung oleh perkembangan terbaru dalam model transformator berbasis perhatian, AttentionGrid membuka dunia mekanisme perhatian untuk praktisi pembelajaran mesin, peneliti, dan penggemar.
Untuk meledak dengan AttentionGrid, instal paket menggunakan PIP:
pip install AttentionGridMenerapkan mekanisme perhatian atau model transformator dengan perhatiangrid semudah:
from AttentionGrid import BlockwiseParallelJax
import jax . numpy as jnp
# Initialize the class
bpjax = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 32 ,
intermediate_size = 3072
)
# Suppose we have hidden_states, attention_mask, and position_ids as input data
hidden_states = jnp . random . rand ( 1 , 100 , 768 )
attention_mask = jnp . random . rand ( 1 , 1 , 100 , 100 )
position_ids = jnp . arange ( 100 ). reshape ( 1 , 100 )
# You can now apply the attention mechanism to your input data
output = bpjax . forward ( hidden_states , attention_mask , position_ids )Kami mendorong Anda untuk berbagi perhatiangrid dengan komunitas Anda! Berikut adalah tautan pembagian cepat untuk beberapa platform media sosial:
Bagikan di Twitter
Bagikan di LinkedIn
Bagikan di Facebook
Bagikan di Reddit
Bagikan di whatsapp
Terima kasih telah mendukung AttentionGrid dan berkontribusi pada demokratisasi AI! Bersama -sama, kita dapat mendorong batasan apa yang mungkin.
Dalam lanskap AI yang luas, mekanisme perhatian telah merevolusi kemampuan kita untuk membuat model yang kuat yang dapat membedakan seluk -beluk dalam data, dengan fokus pada aspek -aspek penting dan meningkatkan kinerja keseluruhan. Visi kami dengan AttentionGrid adalah untuk menjembatani kesenjangan antara mekanisme canggih ini dan aplikasi praktisnya, menyediakan alat yang membuat teknik ini dapat diakses dan mudah diimplementasikan dalam beragam aplikasi AI.
AttentionGrid dirancang dengan arsitektur intuitif dan fleksibel, dipartisi menjadi empat komponen utama:
Core : Ini adalah landasan kerangka kerja kami, kelas -kelas abstrak perumahan yang tata letak struktur dasar untuk mekanisme perhatian dan model transformator.
Perhatian ?: Direktori yang didedikasikan untuk berbagai mekanisme perhatian. Setiap mekanisme perhatian diimplementasikan berdasarkan cetak biru yang disediakan di inti.
Transformers ?: Di sinilah model transformator menjadi hidup, masing -masing pahatan mengikuti desain yang didefinisikan pada inti.
Utils : Kotak alat yang diisi dengan kelas penolong untuk tugas -tugas penting seperti pemuatan model, preprocessing data, dan banyak lagi.
Contoh : Demistifikasi implementasi dengan contoh langsung dan skenario penggunaan.
Struktur Modular : Campurkan dan cocokkan mekanisme perhatian yang berbeda dengan berbagai model transformator.
Ramah Pengguna : Dokumentasi dan contoh yang jelas untuk membantu Anda memulai dengan cepat.
Open Source : Terbuka untuk kontribusi, AttentionGrid berkembang dengan pengetahuan kolektif dan kemajuan bersama.
Untuk contoh yang lebih rinci, silakan merujuk ke folder 'Contoh' di repositori kami.
Kami secara terbuka mengundang kontribusi ke AttentionGrid! Apakah Anda memiliki saran fitur baru, laporan bug, atau ingin menambah kode kami, jangan ragu untuk membuka masalah atau mengirimkan permintaan tarik.
AttentionGrid dengan bangga perangkat lunak open-source, dilisensikan di bawah lisensi Apache.
Mekanisme perhatian telah mengubah AI, memungkinkan mesin untuk 'fokus' pada bagian penting dari data input. Dengan AttentionGrid, kami bertujuan untuk mendemokratisasi akses ke alat -alat yang kuat ini. Kami percaya bahwa masa depan AI terletak pada kekuatan perhatian, dan melalui perhatian, kami berharap dapat mempercepat perjalanan ini. Jelajahi repositori kami, bergabunglah dengan tujuan kami, dan mari kita menavigasi lanskap yang menarik ini bersama -sama!
"Detailnya bukan detailnya. Mereka membuat desain." - Charles Eames
Mengintegrasikan perhatian flash, dan varian
Mengintegrasikan perhatian tengara
Mengintegrasikan perhatian paralel blockwise
Mengintegrasikan perhatian flash jarang dinamis
Mengintegrasikan perhatian silang dari ImageBind
Mengintegrasikan perhatian COLT-5
Mengintegrasikan perhatian multi-kuart
Integrasi pembungkus dari hujan jernih x_transformers, decoder, perhatian, encoder, wrapper transformer
| Mekanisme | Metode panggilan | Contoh impor |
|---|---|---|
| Perhatian diri sendiri | from AttentionGrid import SelfAttention | from AttentionGrid import SelfAttention |
| Perhatian global | from AttentionGrid import GlobalAttention | from AttentionGrid import GlobalAttention |
| Perhatian lokal | from AttentionGrid import LocalAttention | from AttentionGrid import LocalAttention |
| Perhatian hierarkis | from AttentionGrid import HierarchicalAttention | from AttentionGrid import HierarchicalAttention |
| Perhatian jarang dinamis | from AttentionGrid import dynamic_sparse_attention | from AttentionGrid import dynamic_sparse_attention |
| Fungsi kompak | from AttentionGrid import compact | from AttentionGrid import compact |
| Fungsi indeks PAD | from AttentionGrid import pad_index | from AttentionGrid import pad_index |
| Blockwise Parallel perhatian | from AttentionGrid import BlockwiseParallelJax | from AttentionGrid import BlockwiseParallelJax |
| Perhatian Flash | from AttentionGrid import FlashAttention | from AttentionGrid import FlashAttention |
| Perhatian Landmark | from AttentionGrid import LandmarkAttention | from AttentionGrid import LandmarkAttention |
| Perhatian Colt-5 | from AttentionGrid import Colt5Attention | from AttentionGrid import Colt5Attention |
| Perhatian multi-kuarter | from AttentionGrid import MultiQueryAttention | from AttentionGrid import MultiQueryAttention |
| Perhatian melebar | from AttentionGrid import DilatedAttention | from AttentionGrid import DilatedAttention |
Fungsi dynamic_sparse_attention Agora memungkinkan fleksibilitas memilih antara implementasi hash-sparse dan implementasi QK-SPARSE. Tujuan fungsi ini adalah untuk mengarahkan mekanisme perhatian yang jarang secara dinamis berdasarkan sparsity_mode yang dipilih.
Parameter fungsi adalah sebagai berikut:
q : Query Tensor of Shape (batch, n_ctx_q, h, d_head)k : tensor kunci bentuk (batch, n_ctx_kv, h, d_head)v : Nilai tensor bentuk (batch, n_ctx_kv, h, d_head)q_idx & k_idx : Mewakili indeks bucket jika sparsity_mode adalah 'hash' atau apakah akan menjaga kepala yang diberikan jika sparsity_mode adalah 'qk'. Bentuk tensor adalah (batch, n_ctx_q, h) dan (batch, n_ctx_kv, h) masing -masing.sm_scale : konstanta normalisasi, 1/sqrt (d_head) kecuali ditentukan.sparsity_mode : 'hash' untuk memilih implementasi hash-sparse dan 'qk' untuk implementasi QK-SPARSE. sm_scale dihitung secara default jika tidak disediakan, dan jika sparsity_mode yang tidak diketahui diberikan, ia melempar keyError.
Fungsi kemudian memeriksa sparsity_mode dan berdasarkan nilainya, ia memanggil baik hash_sparse_attention atau qk_sparse_attention .
Fungsi compact membangun representasi kompak dari input tensor x menggunakan informasi dari keep_tensor .
Parameter fungsi adalah:
x : input tensor ke kompak, dengan bentuk (batch, n_ctx, h, d_head).keep_tensor : Float tensor bentuk (batch, n_ctx, h) berisi 1 saat kepala disimpan dan 0 sebaliknya. Fungsi pertama kali menghitung indices_per_head yang menghitung jumlah elemen yang tidak dibunuh per kepala. Ini mengurutkan keep_tensor dalam urutan menurun sambil menjaga urutan elemen yang sama (stabil = true). Kemudian mengumpulkan unsur -unsur x berdasarkan tensor indeks. Hasilnya adalah representasi kompak x bersama dengan tensor indeks dan tensor yang mewakili jumlah elemen yang tidak dibunuh per kepala.
pad_index Function Pads indeks tensor untuk mematuhi kernel. Dibutuhkan parameter berikut:
index : tensor indeks asli yang diberikan oleh compact , dengan bentuk (batch, buffer_size, h). Untuk setiap batch dan timestep, itu mewakili indeks kepala yang berasal dari.indices_per_head : Untuk setiap kepala, berisi berapa banyak indeks yang belum dijatuhkan. Ini membuat salinan tensor indeks dan membuat topeng berdasarkan ukuran indices_per_head . Kemudian itu memodifikasi indeks dalam salinan yang sesuai dengan true dalam topeng menjadi sama dengan pad_idx .
Fungsi qk_sparse_attention adalah bagian dari mekanisme perhatian jarang dinamis. Ini digunakan ketika sparsity_mode diatur ke 'qk'. Fungsi ini mengimplementasikan mekanisme perhatian QK-SPARSE dan mensyaratkan bahwa parameter q_keep dan k_keep adalah tipe float.
Pertama -tama membangun representasi kompak dari kueri, kunci, dan tensor nilai menggunakan fungsi compact . Kemudian membanting tensor indeks menggunakan fungsi pad_index . Tensor kemudian dialihkan untuk kompatibilitas dengan kernel. Akhirnya, fungsi tersebut memanggil fungsi qk_sparse_attention_kernel dan mencabut tensor yang dihasilkan kembali ke ruang dimensi asli.
Fungsi hash_sparse_attention adalah bagian dari mekanisme perhatian jarang dinamis. Ini digunakan ketika sparsity_mode diatur ke 'hash'. Fungsi ini mengimplementasikan mekanisme perhatian hash-sparse.
Fungsi ini mengambil parameter input yang sama dengan qk_sparse_attention . Namun, alih -alih parameter q_keep dan k_keep , fungsi hash_sparse_attention membutuhkan q_bucket_idx dan k_bucket_idx yang masing -masing mewakili indeks bucket untuk kueri dan kunci.
Fungsi hash_sparse_attention pertama kali mengurutkan kueri, kunci, dan nilai tensor berdasarkan indeks bucket menggunakan fungsi sort_bucketed_attention . Kemudian membangun representasi kompak dari kueri, kunci, dan tensor yang diurutkan menggunakan fungsi compact . Kemudian membanting tensor indeks menggunakan fungsi pad_index .
Tensor kemudian dialihkan untuk kompatibilitas dengan kernel. Fungsi tersebut kemudian memanggil fungsi hash_sparse_attention_kernel dan mencabut tensor yang dihasilkan kembali ke ruang dimensi asli.
Fungsi sort_bucketed_attention adalah fungsi penolong yang digunakan dalam hash_sparse_attention . Ini mengurutkan tensor input berdasarkan indeks bucket yang diberikan.
Parameter fungsi adalah:
qkv : kueri, kunci, nilai tensor bentuk (batch, n_ctx, h, d_head)qkv_bucket_idx : indeks bucket untuk kueri, kunci, dan nilai bentuk (batch, n_ctx, h) Fungsi pertama mengurutkan tensor qkv_bucket_idx dan mendapatkan indeks yang diurutkan. Kemudian mengurutkan tensor qkv menggunakan indeks yang diurutkan. Ini juga memperluas qkv_bucket_idx menjadi bentuk yang sama dengan qkv untuk kompatibilitas.
Fungsi qk_sparse_attention_kernel adalah fungsi kernel yang digunakan dalam qk_sparse_attention . Ini menghitung jumlah nilai tertimbang berdasarkan softmax dari kueri dan produk utama.
Parameter fungsi adalah:
q : Query Tensor of Shape (batch, n_ctx_q, h, d_head)k : tensor kunci bentuk (batch, n_ctx_kv, h, d_head)v : Nilai tensor bentuk (batch, n_ctx_kv, h, d_head)sm_scale : konstanta normalisasi, 1/sqrt (d_head) kecuali ditentukan. Fungsi hash_sparse_attention_kernel adalah fungsi kernel yang digunakan dalam hash_sparse_attention . Ini bekerja mirip dengan qk_sparse_attention_kernel tetapi menangani ember untuk perhatian hash-sparse.
Parameter fungsi sama dengan yang dari qk_sparse_attention_kernel . Namun, q , k , dan v telah diurutkan dan dipadatkan berdasarkan indeks bucket.
Kernel menghitung produk dari kueri dan kunci, menskalakannya dengan sm_scale , menerapkan Softmax untuk mendapatkan bobot, dan kemudian menghitung jumlah nilai tertimbang.
Harap dicatat bahwa ini adalah interpretasi umum dari dokumentasi, dan memahami dan memodifikasi fungsi-fungsi ini dalam praktik mungkin memerlukan pengetahuan mendalam tentang mekanisme perhatian yang jarang dan prinsip-prinsip pembelajaran yang mendalam.
Fungsi blockwise_compute_attn :
Fungsi blockwise_compute_attn adalah bagian penting dari kelas BlockwiseParallelJax dan digunakan untuk menghitung mekanisme perhatian model secara blockwise.
Parameter:
query , key , value : Parameter ini adalah input utama untuk perhitungan perhatian, masing -masing mewakili kueri, kunci, dan nilai.bias : Parameter opsional yang digunakan untuk menambahkan bias ke skor perhatian sebelum softmax.deterministic : Bendera boolean yang digunakan untuk memutuskan apakah akan menerapkan dropout atau tidak.dropout_rng : Generator nomor acak untuk putus sekolah.attn_pdrop : Probabilitas putus sekolah untuk perhatian.causal_mask : Bendera boolean untuk apakah akan menggunakan topeng perhatian kausal atau tidak.query_chunk_size , key_chunk_size : Ukuran masing -masing kueri dan potongan kunci.dtype : Jenis data perhitungan. Defaultnya adalah jnp.float32 .policy : Parameter ini mendefinisikan kebijakan untuk pos pemeriksaan gradien.precision : Parameter ini digunakan untuk mengatur tingkat presisi untuk perhitungan. Nilai defaultnya adalah lax.Precision.HIGHEST .prevent_cse : Bendera boolean yang digunakan untuk mencegah eliminasi subekspresi umum.Fungsi blockwise_compute_ffn :
Fungsi blockwise_compute_ffn digunakan untuk menghitung jaringan umpan-maju dari model dengan cara yang berlawanan arah jarum jam.
Parameter:
cell : Sel dalam jaringan tempat fungsi diterapkan.inputs : Data input untuk jaringan umpan-maju.chunk_size : Ukuran setiap potongan untuk perhitungan Blockwise.deterministic : Bendera boolean yang digunakan untuk memutuskan apakah akan menerapkan dropout atau tidak.policy : Parameter ini mendefinisikan kebijakan untuk pos pemeriksaan gradien.prevent_cse : Bendera boolean yang digunakan untuk mencegah eliminasi subekspresi umum.Kelas blockwise_lm_head :
Kelas Blockwise_LM_Head adalah modul yang menerapkan transformasi linier diikuti oleh fungsi softmax untuk menghasilkan distribusi di atas kosa kata untuk setiap posisi dalam input.
vocab_size : Ukuran kosakata, yang juga merupakan ukuran dimensi output dari transformasi linier.chunk_size : Ukuran setiap potongan untuk perhitungan Blockwise.policy : Parameter ini mendefinisikan kebijakan untuk pos pemeriksaan gradien.dtype : Jenis data perhitungan. Defaultnya adalah jnp.float32 .prevent_cse : Bendera boolean yang digunakan untuk mencegah eliminasi subekspresi umum.Fungsi blockwise_cross_entropy :
Fungsi blockwise_cross_entropy menghitung kehilangan entri-entropi untuk prediksi model secara blockwise.
Parameter:
logits : Prediksi output model.tokens : Label sejati.valid : Mask yang menentukan posisi yang valid dalam input.chunk_size : Ukuran setiap potongan untuk perhitungan Blockwise.policy : Parameter ini mendefinisikan kebijakan untuk pos pemeriksaan gradien.prevent_cse : Bendera boolean yang digunakan untuk mencegah eliminasi subekspresi umum.Kelas BlockwiseparallelJax :
BlockwiseParallelJax ( q_chunk_size , k_chunk_size , hidden_size , num_heads , rotary_dim , intermediate_size , layer_norm_epsilon = 1e-5 , activation_function = "gelu" , attn_pdrop = 0.0 , resid_pdrop = 0.0 , max_position_embeddings = 1024 , dtype = jnp . float32 , causal = True , policy = 'nothing_saveable' , prevent_cse = False , float32_logits = False )Parameter
q_chunk_size : Integer. Ukuran chunk untuk permintaan dalam perhatian diri.k_chunk_size : Integer. Ukuran chunk untuk kunci dalam perhatian diri.hidden_size : Integer. Dimensi lapisan tersembunyi di transformator.num_heads : Integer. Jumlah kepala perhatian dalam mekanisme perhatian diri.rotary_dim : Integer atau tidak sama sekali. Jumlah dimensi untuk digunakan untuk pengkodean posisi putar.intermediate_size : Integer. Ukuran lapisan perantara di jaringan umpan-maju.layer_norm_epsilon : float. Konstanta kecil untuk mencegah pembagian dengan nol dalam normalisasi lapisan. Default adalah 1e-5 .activation_function : String. Fungsi aktivasi untuk digunakan di jaringan umpan-maju. Default adalah 'gelu' .attn_pdrop : float. Probabilitas putus sekolah untuk mekanisme perhatian. Default adalah 0.0 .resid_pdrop : float. Probabilitas putus sekolah untuk koneksi residual. Default adalah 0.0 .max_position_embeddings : Integer. Jumlah maksimum embeddings posisi untuk digunakan. Default adalah 1024 .dtype : jnp.dtype. Jenis data yang akan digunakan untuk perhitungan. Default adalah jnp.float32 .causal : Boolean. Apakah akan menggunakan mode kausal (auto-regresif) atau tidak. Default itu True .policy : String. Kebijakan untuk Checkpointing Gradients. Default adalah 'nothing_saveable' .prevent_cse : boolean. Apakah akan mencegah eliminasi subekspresi umum (CSE). Default False .float32_logits : boolean. Apakah akan menggunakan float32 untuk perhitungan logit. Default False .Metode
Metode utama kelas BlockwiseParallelJax adalah metode forward , yang melakukan lintasan ke depan dari blok transformator.
forward ( hidden_states , attention_mask , position_ids , deterministic = True , init_cache = False )hidden_states : jnp.ndarray. Tensor input ke blok transformator. Seharusnya memiliki bentuk (batch_size, sequence_length, hidden_size) .attention_mask : jnp.ndarray. Topeng perhatian untuk mekanisme perhatian diri. Seharusnya memiliki bentuk (batch_size, 1, 1, sequence_length) .position_ids : jnp.ndarray. ID Posisi untuk Pengkodean Posisi. Itu harus memiliki bentuk (1, sequence_length) .deterministic : Boolean. Apakah akan menggunakan mode deterministik (tidak ada putus sekolah) atau tidak. Default itu True .init_cache : boolean. Apakah akan menginisialisasi cache untuk decoding cepat. Default False . Metode ini mengembalikan tensor output dari blok transformator, yang memiliki bentuk yang sama dengan hidden_states .
Contoh penggunaan
Contoh berikut menunjukkan cara menggunakan kelas BlockwiseParallelJax .
# Initialize
from jax import random
import jax . numpy as jnp
from AttentionGrid import BlockwiseParallelJax
# Initialize transformer block
block = BlockwiseParallelJax (
q_chunk_size = 64 ,
k_chunk_size = 64 ,
hidden_size = 768 ,
num_heads = 12 ,
rotary_dim = 64 ,
intermediate_size = 3072 ,
)
# Create a batch of input tensors
key = random . PRNGKey ( 0 )
batch_size = 8
sequence_length = 128
hidden_states = random . normal ( key , ( batch_size , sequence_length , block . hidden_size ))
# Create attention mask
attention_mask = jnp . ones (( batch_size , 1 , 1 , sequence_length ))
# Create position ids
position_ids = jnp . arange ( sequence_length )[ None , :]
# Forward pass
output = block . forward ( hidden_states , attention_mask , position_ids )
print ( output . shape ) # prints: (8, 128, 768) FusedLandmarkAttention Ini adalah kelas Function Pytorch yang merangkum fungsi maju dan mundur dari mekanisme perhatian landmark yang menyatu.
forward(ctx, q, k, v, n_prefix_q, sm_scale, block_size)Fungsi ini melakukan lulus ke depan dari perhatian tengara yang menyatu.
ctx : Suatu objek yang dapat kami simpan variabel untuk digunakan di pass mundur. Disediakan oleh sistem autograd Pytorch.q : Tensor kueri. Diasumsikan berdekatan, dan bentuknya harus (batch, neheads, seqlen_q, d).k : The Keys Tensor. Diasumsikan berdekatan, dan bentuknya harus cocok dengan bentuk Q, yaitu, (batch, neheads, seqlen_k, d).v : Nilai Tensor. Diasumsikan berdekatan, dan bentuknya harus cocok dengan bentuk Q dan K, yaitu, (batch, neheads, seqlen_k, d).n_prefix_q : Jumlah awalan dalam kueri.sm_scale : Faktor penskalaan yang digunakan dalam operasi softmax.block_size : Ukuran blok untuk melakukan operasi blok-bijaksana. o : Tensor output dari lintasan depan mekanisme perhatian landmark yang menyatu. backward(ctx, do)Fungsi ini melakukan lulus mundur dari perhatian landmark yang menyatu, yaitu, menghitung gradien.
ctx : Suatu objek dari mana kita dapat mengambil variabel yang disimpan di Forward Pass. Disediakan oleh sistem autograd Pytorch.do : Gradien kerugian sehubungan dengan output fungsi maju. None .fused_landmark_attention(q, k, v, is_mem, sm_scale=None, block_size=64) Fungsi ini adalah pembungkus yang nyaman untuk kelas FusedLandmarkAttention .
q : Tensor kueri.k : The Keys Tensor.v : Nilai Tensor.is_mem : tensor boolean yang menunjukkan apakah setiap pasangan nilai kunci harus diperlakukan sebagai memori. Seharusnya memiliki panjang yang sama dengan panjang urutan tombol.sm_scale : Faktor penskalaan yang digunakan dalam operasi softmax. Jika None , itu akan diatur ke 1.0 / sqrt(d) .block_size : Ukuran blok untuk melakukan operasi blok-bijaksana. Berikut adalah contoh dasar tentang cara menggunakan fungsi fused_landmark_attention .
import torch
from AttentionGrid import fused_landmark_attention
# Initialize some tensors
batch = 8
nheads = 12
seqlen = 128
d = 64
q = torch . randn ( batch , nheads , seqlen , d )
k = torch . randn ( batch , nheads , seqlen , d )
v = torch . randn ( batch , nheads , seqlen , d )
is_mem = torch . zeros ( seqlen , dtype = torch . bool )
# Call the function
output = fused_landmark_attention ( q , k , v , is_mem )
print ( output . shape ) # prints: (8, 12, 128, 64)Contoh ini pertama -tama menginisialisasi beberapa tensor untuk berfungsi sebagai kueri, kunci
, dan nilai. Kemudian disebut fungsi fused_landmark_attention dan mencetak bentuk tensor output.
import torch
import torch . nn as nn
from AttentionGrid import DilatedAttention
# Replace this with your correct GPU device
device = "cuda:0"
dtype = torch . float16
# Create an instance of DilatedAttention
d_model = 512
num_heads = 8
dilation_rate = 2
segment_size = 64
dropout = 0.2 # Specify the dropout rate
attention = DilatedAttention (
d_model = d_model ,
num_heads = num_heads ,
dilation_rate = dilation_rate ,
segment_size = segment_size ,
dropout = dropout ,
). to ( device , dtype = dtype )
# Create some dummy input data
batch_size = 16
seq_len = 128
input_dim = d_model
inputs = torch . randn ( batch_size , seq_len , input_dim , device = device , dtype = dtype )
# Forward pass
outputs = attention ( inputs )
# Print the output shape
print ( outputs . shape ) # Expected: [batch_size, seq_len, d_model] Dalam contoh di atas, kami membuat instance dari kelas DilatedAttention dengan hiperparameter yang ditentukan. Kami kemudian menghasilkan beberapa data input dummy dan melewatkannya melalui mekanisme perhatian untuk mendapatkan output. Akhirnya, kami mencetak bentuk tensor keluaran.
Kelas DilatedAttention mengimplementasikan perhatian melebar, yang memperluas bidang yang penuh perhatian secara eksponensial saat jarak antara token tumbuh. Ini mewarisi dari torch.nn.Module dan dapat digunakan sebagai pengganti drop-in untuk mekanisme perhatian standar dalam model transformator.
d_model (int): Dimensi input dan output embeddings.num_heads (int): Jumlah kepala perhatian.dilation_rate (int): Laju pelebaran untuk menghabiskan urutan input.segment_size (int): Ukuran setiap segmen setelah sparsifikasi.dropout (float, opsional): Probabilitas putus sekolah untuk diterapkan pada output perhatian. Default: 0,0 (tidak ada putus sekolah).x (Tensor): Tensor input bentuk (batch_size, seq_len, d_model) .output (Tensor): Tensor output bentuk (batch_size, seq_len, d_model) . Harap dicatat bahwa tensor input harus pada perangkat yang benar (misalnya, GPU) dan memiliki tipe data yang sesuai ( dtype ).
