mod compute;
#[cfg(test)]
mod tests;
use crate::error::Result;
use crate::ops::scaled_dot_product_attention::ScaledDotProductAttention;
use crate::tensor::Tensor;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct MHAProjectionParams {
pub batch_size: u32,
pub seq_len: u32,
pub d_model: u32,
pub num_heads: u32,
pub head_dim: u32,
}
pub struct MultiHeadAttention {
query: Tensor,
key: Tensor,
value: Tensor,
w_q: Tensor,
w_k: Tensor,
w_v: Tensor,
w_o: Tensor,
batch_size: usize,
seq_len: usize,
d_model: usize,
num_heads: usize,
head_dim: usize,
}
impl MultiHeadAttention {
pub fn new(
query: Tensor,
key: Tensor,
value: Tensor,
w_q: Tensor,
w_k: Tensor,
w_v: Tensor,
w_o: Tensor,
num_heads: usize,
) -> Result<Self> {
let q_shape = query.shape();
let k_shape = key.shape();
let v_shape = value.shape();
if q_shape.len() != 3 || k_shape.len() != 3 || v_shape.len() != 3 {
return Err(crate::error::BarracudaError::InvalidInput {
message: "All inputs must be 3D tensors [batch, seq_len, d_model]".to_string(),
});
}
let batch_size = q_shape[0];
let seq_len = q_shape[1];
let d_model = q_shape[2];
if k_shape != q_shape || v_shape != q_shape {
return Err(crate::error::BarracudaError::shape_mismatch(
q_shape.to_vec(),
if k_shape == q_shape {
v_shape.to_vec()
} else {
k_shape.to_vec()
},
));
}
if !d_model.is_multiple_of(num_heads) {
return Err(crate::error::BarracudaError::InvalidInput {
message: format!(
"d_model ({d_model}) must be divisible by num_heads ({num_heads})"
),
});
}
let head_dim = d_model / num_heads;
let w_q_shape = w_q.shape();
let w_k_shape = w_k.shape();
let w_v_shape = w_v.shape();
let w_o_shape = w_o.shape();
let expected_weight_shape = vec![d_model, d_model];
if w_q_shape != expected_weight_shape
|| w_k_shape != expected_weight_shape
|| w_v_shape != expected_weight_shape
|| w_o_shape != expected_weight_shape
{
return Err(crate::error::BarracudaError::shape_mismatch(
expected_weight_shape,
w_q_shape.to_vec(),
));
}
use std::sync::Arc;
if !Arc::ptr_eq(query.device(), key.device())
|| !Arc::ptr_eq(query.device(), value.device())
|| !Arc::ptr_eq(query.device(), w_q.device())
|| !Arc::ptr_eq(query.device(), w_k.device())
|| !Arc::ptr_eq(query.device(), w_v.device())
|| !Arc::ptr_eq(query.device(), w_o.device())
{
return Err(crate::error::BarracudaError::device(
"All tensors must be on the same device",
));
}
Ok(Self {
query,
key,
value,
w_q,
w_k,
w_v,
w_o,
batch_size,
seq_len,
d_model,
num_heads,
head_dim,
})
}
pub fn execute(self) -> Result<Tensor> {
let device = self.query.device();
let mut encoder = device.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("MultiHeadAttention Encoder"),
});
let q_proj_buffer =
compute::execute_projection(&self, device, &self.query, &self.w_q, &mut encoder)?;
let k_proj_buffer =
compute::execute_projection(&self, device, &self.key, &self.w_k, &mut encoder)?;
let v_proj_buffer =
compute::execute_projection(&self, device, &self.value, &self.w_v, &mut encoder)?;
device.submit_commands(Some(encoder.finish()));
let q_proj = Tensor::from_buffer(
q_proj_buffer,
vec![self.batch_size, self.num_heads, self.seq_len, self.head_dim],
device.clone(),
);
let k_proj = Tensor::from_buffer(
k_proj_buffer,
vec![self.batch_size, self.num_heads, self.seq_len, self.head_dim],
device.clone(),
);
let v_proj = Tensor::from_buffer(
v_proj_buffer,
vec![self.batch_size, self.num_heads, self.seq_len, self.head_dim],
device.clone(),
);
let attention_output = ScaledDotProductAttention::new(q_proj, k_proj, v_proj)?.execute()?;
let mut encoder = device.create_encoder_guarded(&wgpu::CommandEncoderDescriptor {
label: Some("MultiHeadAttention Output Encoder"),
});
let output_buffer = compute::execute_output_projection(
&self,
device,
attention_output.buffer(),
&mut encoder,
)?;
device.submit_commands(Some(encoder.finish()));
Ok(Tensor::from_buffer(
output_buffer,
vec![self.batch_size, self.seq_len, self.d_model],
device.clone(),
))
}
pub(super) fn batch_size(&self) -> usize {
self.batch_size
}
pub(super) fn seq_len(&self) -> usize {
self.seq_len
}
pub(super) fn d_model(&self) -> usize {
self.d_model
}
pub(super) fn num_heads(&self) -> usize {
self.num_heads
}
pub(super) fn head_dim(&self) -> usize {
self.head_dim
}
pub(super) fn w_o(&self) -> &Tensor {
&self.w_o
}
}