Struct lfa::basis::fixed::KernelProjector

pub struct KernelProjector<I, K> {
    pub prototypes: Vec<Prototype<I, K>>,
}

Kernel machine basis projector.

Fields

prototypes: Vec<Prototype<I, K>>

Methods

impl<I, K: Kernel<I>> KernelProjector<I, K>

pub fn new(prototypes: Vec<Prototype<I, K>>) -> Self

pub fn homogeneous(
    centroids: impl IntoIterator<Item = impl Into<I>>,
    kernel: K
) -> Self

impl KernelProjector<Vector<f64>, ExpQuad>

pub fn exp_quad(partitioning: LinearSpace<Partition>) -> Self

impl KernelProjector<Vector<f64>, Matern32>

pub fn matern_32(partitioning: LinearSpace<Partition>) -> Self

impl KernelProjector<Vector<f64>, Matern52>

pub fn matern_52(partitioning: LinearSpace<Partition>) -> Self

Trait Implementations

impl<I, K: Kernel<I>> Projector<I> for KernelProjector<I, K>

fn project(&self, input: &I) -> Projection

Project data from an input space onto the basis.

fn project_expanded(&self, input: &I) -> DenseT

Project data from an input space onto the basis and expand into a dense vector form using Projection::expanded(self.dim()).

impl<I, K: Kernel<I>> Composable for KernelProjector<I, K>

fn lfa<A: Approximator<Projection>>(self, approximator: A) -> LFA<Self, A>

Return an LFA using this Projector instance and a given Approximator.

fn stack<P>(self, p: P) -> Stack<Self, P>

Return a Stack of this Projector over another.

fn add<P: Space>(self, p: P) -> Sum<Self, P> where
    Self: Space, 

Return the Sum of this Projector and another.

fn subtract<P: Space>(self, p: P) -> Sum<Self, Negate<P>> where
    Self: Space, 

Return the Sum of this Projector and the Negated other.

fn shift(self, offset: f64) -> Shift<Self>

Return the original Projector with all activations Shifted by some offset.

fn multiply<P: Space>(self, p: P) -> Product<Self, P> where
    Self: Space, 

Return the Product of this Projector and another.

fn divide<P: Space>(self, p: P) -> Product<Self, Reciprocal<P>> where
    Self: Space, 

Return the Product of this Projector and the Reciprocal of the other.

fn scale(self, factor: f64) -> Scale<Self>

Return the original Projector with all activations Scaled by some factor.

fn normalise_l1(self) -> L1Normalise<Self>

Return the original Projector with all activations normalised in L₁.

fn normalise_l2(self) -> L2Normalise<Self>

Return the original Projector with all activations normalised in L₂.

fn normalise_lp(self, p: u8) -> LpNormalise<Self>

Return the original Projector with all activations normalised in Lp.

fn normalise_linf(self) -> LinfNormalise<Self>

Return the original Projector with all activations normalised in L∞.

fn with_constant(self) -> Stack<Self, Constant>

Return the a Stack of this Projector with a single constant feature term.

impl<I: Clone, K: Clone> Clone for KernelProjector<I, K>

fn clone(&self) -> KernelProjector<I, K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug, K: Debug> Debug for KernelProjector<I, K>

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

Formats the value using the given formatter.

impl<'de, I, K> Deserialize<'de> for KernelProjector<I, K> where
    I: Deserialize<'de>,
    K: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<I, K> Serialize for KernelProjector<I, K> where
    I: Serialize,
    K: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<I, K: Kernel<I>> Space for KernelProjector<I, K>

type Value = Projection

The data representation of the space.

fn dim(&self) -> usize

Return the dimensionality of the space.

fn card(&self) -> Card

Return the number of elements in the set composing the space.