Struct FftAttention

pub struct FftAttention<A = f32> { /* private fields */ }

FFT-based attention mechanism for temporal pattern recognition.

This implementation is based on “The FFT Strikes Back: Fast and Accurate Spectral-Pruning Neural Networks” (https://arxiv.org/pdf/2502.18394).

The mechanism:

1. Transforms input to frequency domain using FFT
2. Applies soft thresholding to frequency components based on energy distribution
3. Enhances important frequency patterns
4. Returns to time domain with inverse FFT

The attention mechanism is parameterized by steepness and threshold, which control the sensitivity of the attention to frequency components.

Implementations

impl<A> FftAttention<A>

pub fn new() -> Self

where A: FromPrimitive,

Create a new attention module with the given parameters

pub const fn steepness(&self) -> &A

returns an immutable reference to the steepness of the attention module

pub fn steepness_mut(&mut self) -> &mut A

returns a mutable reference to the steepness of the attention module to allow for gradient descent

pub const fn threshold(&self) -> &A

returns an immutable reference to the threshold of the attention module

pub fn threshold_mut(&mut self) -> &mut A

returns a mutable reference to the threshold of the attention module to allow for gradient descent

pub fn set_steepness(&mut self, steepness: A)

set the steepness of the attention mechanism

pub fn set_threshold(&mut self, threshold: A)

set the threshold of the attention mechanism

pub fn with_steepness(self, steepness: A) -> Self

consumes the current instance and returns another with the given steepness

pub fn with_threshold(self, threshold: A) -> Self

consumes the current instance and returns another with the given threshold

pub fn forward<X, Y>(&self, input: &X) -> Result<Y>

where Self: Forward<X, Output = Y>,

Trait Implementations

impl<A: Clone> Clone for FftAttention<A>

fn clone(&self) -> FftAttention<A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug> Debug for FftAttention<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A> Default for FftAttention<A>

where A: FromPrimitive,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, A> Deserialize<'de> for FftAttention<A>

where A: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, S> Forward<ArrayBase<S, Dim<[usize; 1]>>> for FftAttention<A>

where A: FftNum + Float + FromPrimitive + ScalarOperand, S: Data<Elem = A>,

type Output = ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>

fn forward(&self, input: &ArrayBase<S, Ix1>) -> Result<Self::Output>

a single forward step

fn forward_then<F>(&self, input: &Rhs, then: F) -> Result<Self::Output, Error>

where F: FnOnce(Self::Output) -> Self::Output,

this method enables the forward pass to be generically activated using some closure. This is useful for isolating the logic of the forward pass from that of the activation function and is often used by layers and models.

impl<A, S> Forward<ArrayBase<S, Dim<[usize; 2]>>> for FftAttention<A>

where A: FftNum + Float + FromPrimitive + ScalarOperand, S: Data<Elem = A>,

type Output = ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>

fn forward(&self, input: &ArrayBase<S, Ix2>) -> Result<Self::Output>

a single forward step

fn forward_then<F>(&self, input: &Rhs, then: F) -> Result<Self::Output, Error>

where F: FnOnce(Self::Output) -> Self::Output,

this method enables the forward pass to be generically activated using some closure. This is useful for isolating the logic of the forward pass from that of the activation function and is often used by layers and models.

impl<A: Hash> Hash for FftAttention<A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: Ord> Ord for FftAttention<A>

fn cmp(&self, other: &FftAttention<A>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<A: PartialEq> PartialEq for FftAttention<A>

fn eq(&self, other: &FftAttention<A>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: PartialOrd> PartialOrd for FftAttention<A>

fn partial_cmp(&self, other: &FftAttention<A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A> Serialize for FftAttention<A>

where A: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A: Copy> Copy for FftAttention<A>

impl<A: Eq> Eq for FftAttention<A>

impl<A> StructuralPartialEq for FftAttention<A>