mod backward;
mod error;
mod forward;
mod validation;
use core::num::NonZeroUsize;
use leto::{ArrayView, ArrayViewMut};
pub use backward::scaled_dot_product_attention_backward_accumulate;
pub use error::{AttentionError, AttentionOperand, AttentionResult};
pub use forward::scaled_dot_product_attention_into;
#[derive(Clone, Copy)]
pub enum AttentionMask<'a, T> {
Unmasked,
Causal,
Keep(ArrayView<'a, T, 3>),
CausalKeep(ArrayView<'a, T, 3>),
GroupedKeep(GroupedKeepMask<'a, T>),
CausalGroupedKeep(GroupedKeepMask<'a, T>),
}
impl<'a, T> AttentionMask<'a, T> {
pub(super) const fn view(self) -> Option<ArrayView<'a, T, 3>> {
match self {
Self::Unmasked | Self::Causal | Self::GroupedKeep(_) | Self::CausalGroupedKeep(_) => {
None
}
Self::Keep(view) | Self::CausalKeep(view) => Some(view),
}
}
pub(super) const fn grouped(self) -> Option<GroupedKeepMask<'a, T>> {
match self {
Self::GroupedKeep(mask) | Self::CausalGroupedKeep(mask) => Some(mask),
Self::Unmasked | Self::Causal | Self::Keep(_) | Self::CausalKeep(_) => None,
}
}
pub(super) const fn is_causal(&self) -> bool {
matches!(
self,
Self::Causal | Self::CausalKeep(_) | Self::CausalGroupedKeep(_)
)
}
}
#[derive(Clone, Copy)]
pub struct GroupedKeepMask<'a, T> {
pub(super) view: ArrayView<'a, T, 2>,
pub(super) batches_per_group: NonZeroUsize,
}
impl<'a, T> GroupedKeepMask<'a, T> {
#[must_use]
pub const fn new(view: ArrayView<'a, T, 2>, batches_per_group: NonZeroUsize) -> Self {
Self {
view,
batches_per_group,
}
}
}
pub struct AttentionGradients<'a, T> {
pub(super) query: Option<ArrayViewMut<'a, T, 3>>,
pub(super) key: Option<ArrayViewMut<'a, T, 3>>,
pub(super) value: Option<ArrayViewMut<'a, T, 3>>,
}
impl<'a, T> AttentionGradients<'a, T> {
#[must_use]
pub const fn new(
query: Option<ArrayViewMut<'a, T, 3>>,
key: Option<ArrayViewMut<'a, T, 3>>,
value: Option<ArrayViewMut<'a, T, 3>>,
) -> Self {
Self { query, key, value }
}
pub(super) const fn has_any(&self) -> bool {
self.query.is_some() || self.key.is_some() || self.value.is_some()
}
}