use crate::error::{BarracudaError, Result};
use crate::tensor::Tensor;
mod projections;
#[cfg(test)]
mod tests;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub(crate) struct MhaParams {
pub batch_size: u32,
pub seq_len: u32,
pub d_model: u32,
pub num_heads: u32,
pub head_dim: u32,
pub _padding: [u32; 3],
}
pub struct MultiHeadAttention {
query: Tensor,
key: Tensor,
value: Tensor,
w_q: Tensor,
w_k: Tensor,
w_v: Tensor,
w_o: Tensor,
num_heads: 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> {
if query.shape().len() != 3 || key.shape().len() != 3 || value.shape().len() != 3 {
return Err(BarracudaError::shape_mismatch(
query.shape().to_vec(),
vec![0, 0, 0], ));
}
if query.shape()[0] != key.shape()[0] || query.shape()[0] != value.shape()[0] {
return Err(BarracudaError::shape_mismatch(
query.shape().to_vec(),
key.shape().to_vec(),
));
}
if query.shape()[2] != key.shape()[2] || key.shape()[2] != value.shape()[2] {
return Err(BarracudaError::shape_mismatch(
query.shape().to_vec(),
key.shape().to_vec(),
));
}
if key.shape() != value.shape() {
return Err(BarracudaError::shape_mismatch(
key.shape().to_vec(),
value.shape().to_vec(),
));
}
if w_q.shape().len() != 2
|| w_k.shape().len() != 2
|| w_v.shape().len() != 2
|| w_o.shape().len() != 2
{
return Err(BarracudaError::shape_mismatch(
w_q.shape().to_vec(),
vec![0, 0], ));
}
let d_model = query.shape()[2];
if w_q.shape() != [d_model, d_model]
|| w_k.shape() != [d_model, d_model]
|| w_v.shape() != [d_model, d_model]
|| w_o.shape() != [d_model, d_model]
{
return Err(BarracudaError::shape_mismatch(
w_q.shape().to_vec(),
vec![d_model, d_model],
));
}
if !d_model.is_multiple_of(num_heads) {
return Err(BarracudaError::InvalidOperation {
op: "multi_head_attention".to_string(),
reason: format!("d_model ({d_model}) must be divisible by num_heads ({num_heads})"),
});
}
Ok(Self {
query,
key,
value,
w_q,
w_k,
w_v,
w_o,
num_heads,
})
}
pub fn execute(self) -> Result<Tensor> {
let batch_size = self.query.shape()[0];
let q_seq_len = self.query.shape()[1];
let d_model = self.query.shape()[2];
let head_dim = d_model / self.num_heads;
let params = MhaParams {
batch_size: batch_size as u32,
seq_len: q_seq_len as u32,
d_model: d_model as u32,
num_heads: self.num_heads as u32,
head_dim: head_dim as u32,
_padding: [0; 3],
};
let q_proj = self.project_with_head_split(&self.query, &self.w_q, ¶ms)?;
let k_proj = self.project_with_head_split(&self.key, &self.w_k, ¶ms)?;
let v_proj = self.project_with_head_split(&self.value, &self.w_v, ¶ms)?;
let attention_output = q_proj.attention(&k_proj, &v_proj)?;
self.concat_and_project(&attention_output, &self.w_o, ¶ms)
}
}
impl Tensor {
pub fn multi_head_attention(
self,
key: &Self,
value: &Self,
w_q: &Self,
w_k: &Self,
w_v: &Self,
w_o: &Self,
num_heads: usize,
) -> Result<Self> {
MultiHeadAttention::new(
self,
key.clone(),
value.clone(),
w_q.clone(),
w_k.clone(),
w_v.clone(),
w_o.clone(),
num_heads,
)?
.execute()
}
}