Struct Score

pub struct Score<A, D>
where
    D: Dimension,
{ /* private fields */ }

Score is a created as a result of invoking an attention mechanism;

• attention: the actual result; returns the dot product of the score with the value tensor
• score: the attention score tensor

Implementations

impl<A, D> Score<A, D>

where D: Dimension,

pub fn into_attention(self) -> Array<A, D>

Consumes the instance and returns the attention tensor.

pub fn into_score(self) -> Array<A, D>

Consumes the container and returns the score tensor.

pub fn attention(&self) -> &Array<A, D>

Retrieve the attention tensor.

pub fn score(&self) -> &Array<A, D>

Retrieve the score tensor

Trait Implementations

impl<A: Clone, D> Clone for Score<A, D>

where D: Dimension + Clone,

fn clone(&self) -> Score<A, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, D> Debug for Score<A, D>

where A: Debug, D: Dimension,

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

Formats the value using the given formatter.

impl<A, D> Display for Score<A, D>

where A: Display, D: Dimension,

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

Formats the value using the given formatter.

impl<A, D> From<(ArrayBase<OwnedRepr<A>, D>, ArrayBase<OwnedRepr<A>, D>)> for Score<A, D>

where D: Dimension,

fn from((attention, score): (Array<A, D>, Array<A, D>)) -> Self

Converts to this type from the input type.

impl<A, D> From<Score<A, D>> for (Array<A, D>, Array<A, D>)

where D: Dimension,

fn from(score: Score<A, D>) -> Self

Converts to this type from the input type.

impl<A: Hash, D> Hash for Score<A, D>

where D: Dimension + Hash,

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: PartialEq, D> PartialEq for Score<A, D>

where D: Dimension + PartialEq,

fn eq(&self, other: &Score<A, D>) -> 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, D> Copy for Score<A, D>

where A: Copy, D: Copy + Dimension, Array<A, D>: Copy,

impl<A: Eq, D> Eq for Score<A, D>

where D: Dimension + Eq,

impl<A, D> StructuralPartialEq for Score<A, D>

where D: Dimension,