Struct ParamsBase

pub struct ParamsBase<S = OwnedRepr<f64>, D = Ix2, K = Biased>
where
    D: Dimension,
    S: RawData,
{ /* private fields */ }

The ParamsBase struct is a generic store for linear parameters. The store mimics the underlying ArrayBase, enabling developers to specify the data repr and dimension. Additionally, the store is parameterized to accept a K type, used to designate the store as either Biased or Unbiased.

Implementations

impl<A, S, D, K> ParamsBase<S, D, K>

where D: RemoveAxis, S: RawData<Elem = A>,

pub fn from_elem<Sh>(shape: Sh, elem: A) -> Self

where A: Clone, K: ParamMode, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

pub fn into_biased(self) -> ParamsBase<S, D, Biased>

where A: Default, K: 'static, S: DataOwned,

pub fn into_unbiased(self) -> ParamsBase<S, D, Unbiased>

pub const fn weights(&self) -> &ArrayBase<S, D>

pub fn weights_mut(&mut self) -> &mut ArrayBase<S, D>

pub fn features(&self) -> Features

pub fn in_features(&self) -> usize

pub fn out_features(&self) -> usize

pub fn is_biased(&self) -> bool

where K: 'static,

Returns true if the parameter store is biased; Compares the TypeId of the store with the Biased type.

pub fn new<Sh>(shape: Sh) -> Self

where K: ParamMode, Sh: ShapeBuilder<Dim = D>, A: Default, S: DataOwned,

pub fn ones<Sh>(shape: Sh) -> Self

where K: ParamMode, Sh: ShapeBuilder<Dim = D>, A: Clone + One, S: DataOwned,

pub fn zeros<Sh>(shape: Sh) -> Self

where K: ParamMode, Sh: ShapeBuilder<Dim = D>, A: Clone + Zero, S: DataOwned,

pub fn dim(&self) -> D::Pattern

Return the pattern of the dimension

pub fn ndim(&self) -> usize

Returns rank (ndim) of the dimension

pub fn raw_dim(&self) -> D

Returns the raw dimension D

pub fn shape(&self) -> &[usize]

Returns a reference to the current dimension, as a slice.

pub fn into_owned(self) -> ParamsBase<OwnedRepr<A>, D, K>

where A: Clone, S: Data,

pub fn into_shared(self) -> ParamsBase<OwnedArcRepr<A>, D, K>

where A: Clone, S: DataOwned,

pub fn to_owned(&self) -> ParamsBase<OwnedRepr<A>, D, K>

where A: Clone, S: Data,

pub fn to_shared(&self) -> ParamsBase<OwnedArcRepr<A>, D, K>

where A: Clone, S: DataOwned,

pub fn view(&self) -> ParamsBase<ViewRepr<&A>, D, K>

where A: Clone, S: Data,

pub fn view_mut(&mut self) -> ParamsBase<ViewRepr<&mut A>, D, K>

where A: Clone, S: DataMut,

impl<A, S, D> ParamsBase<S, D, Biased>

where D: RemoveAxis, S: RawData<Elem = A>,

pub fn biased<Sh>(shape: Sh) -> Self

where A: Default, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Create a new biased parameter store from the given shape.

pub fn bias(&self) -> &ArrayBase<S, D::Smaller>

Return an unwraped, immutable reference to the bias array.

pub fn bias_mut(&mut self) -> &mut ArrayBase<S, D::Smaller>

Return an unwraped, mutable reference to the bias array.

impl<A, S, D> ParamsBase<S, D, Unbiased>

where D: Dimension, S: RawData<Elem = A>,

pub fn unbiased<Sh>(shape: Sh) -> Self

where A: Default, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Create a new unbiased parameter store from the given shape.

impl<A, S, K> ParamsBase<S, Ix2, K>

where K: 'static, S: RawData<Elem = A>,

pub fn set_node( &mut self, idx: usize, node: (ArrayBase<OwnedRepr<A>, Ix1>, Option<ArrayBase<OwnedRepr<A>, Ix0>>), )

where A: Clone + Default, S: DataMut + DataOwned,

impl<A, S, D, K> ParamsBase<S, D, K>

where A: Clone + Float + SampleUniform, D: RemoveAxis, K: ParamMode, S: RawData<Elem = A>, StandardNormal: Distribution<A>, <A as SampleUniform>::Sampler: Clone,

pub fn uniform(self) -> LinearParams<A, K, D>

where S: DataOwned,

pub fn uniform_between(self, low: A, high: A) -> LinearParams<A, K, D>

where S: DataOwned,

impl<A, K, S, D> ParamsBase<S, D, K>

where D: RemoveAxis, S: RawData<Elem = A>,

pub fn activate<F, X, Y>(&mut self, args: &X, f: F) -> Y

where F: for<'a> Fn(&'a Y) -> Y, S: Data<Elem = A>, Self: Predict<X, Output = Y>,

Trait Implementations

impl<A, S, D, K> Borrow<ParamsBase<S, D, K>> for Linear<A, K, D, S>

where D: RemoveAxis, S: RawData<Elem = A>,

fn borrow(&self) -> &ParamsBase<S, D, K>

Immutably borrows from an owned value.

impl<A, S, D, K> BorrowMut<ParamsBase<S, D, K>> for Linear<A, K, D, S>

where D: RemoveAxis, S: RawData<Elem = A>,

fn borrow_mut(&mut self) -> &mut ParamsBase<S, D, K>

Mutably borrows from an owned value.

impl<A, S, D> Clone for ParamsBase<S, D>

where A: Clone, D: RemoveAxis, S: RawDataClone<Elem = A>,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, S, D> Default for ParamsBase<S, D, Biased>

where A: Default, D: Dimension, S: DataOwned<Elem = A>,

fn default() -> Self

Returns the “default value” for a type.

impl<A, S, D> Default for ParamsBase<S, D, Unbiased>

where A: Default, D: Dimension, S: DataOwned<Elem = A>,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, A, S, D, K> Deserialize<'a> for ParamsBase<S, D, K>

where A: Deserialize<'a>, D: Deserialize<'a> + RemoveAxis, S: DataOwned<Elem = A>, <D as Dimension>::Smaller: Deserialize<'a> + Dimension,

fn deserialize<Der>(deserializer: Der) -> Result<Self, Der::Error>

where Der: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<A> From<(ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, A)> for ParamsBase<OwnedRepr<A>, Ix1, Biased>

where A: Clone,

fn from((weights, bias): (Array1<A>, A)) -> Self

Converts to this type from the input type.

impl<A, K> From<(ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, Option<A>)> for ParamsBase<OwnedRepr<A>, Ix1, K>

where A: Clone,

fn from((weights, bias): (Array1<A>, Option<A>)) -> Self

Converts to this type from the input type.

impl<A, S, D> From<(ArrayBase<S, D>, ArrayBase<S, <D as Dimension>::Smaller>)> for ParamsBase<S, D, Biased>

where D: RemoveAxis, S: RawData<Elem = A>,

fn from((weights, bias): (ArrayBase<S, D>, ArrayBase<S, D::Smaller>)) -> Self

Converts to this type from the input type.

impl<A, S, D, K> From<(ArrayBase<S, D>, Option<ArrayBase<S, <D as Dimension>::Smaller>>)> for ParamsBase<S, D, K>

where D: RemoveAxis, S: RawData<Elem = A>,

fn from( (weights, bias): (ArrayBase<S, D>, Option<ArrayBase<S, D::Smaller>>), ) -> Self

Converts to this type from the input type.

impl<A, S> FromIterator<(ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, Option<ArrayBase<OwnedRepr<A>, Dim<[usize; 0]>>>)> for ParamsBase<S, Ix2>

where A: Clone + Default, S: DataOwned<Elem = A> + DataMut,

fn from_iter<I: IntoIterator<Item = (Array1<A>, Option<Array0<A>>)>>( nodes: I, ) -> Self

Creates a value from an iterator.

impl<A, S, D, K> Initialize<A, D> for ParamsBase<S, D, K>

where D: RemoveAxis, K: ParamMode, S: DataOwned<Elem = A>, StandardNormal: Distribution<A>,

type Data = S

fn rand<Sh, Dstr>(shape: Sh, distr: Dstr) -> Self

where Sh: ShapeBuilder<Dim = D>, Dstr: Clone + Distribution<A>,

Generate a random array using the given distribution

fn rand_with<Sh, Ds, R>(shape: Sh, distr: Ds, rng: &mut R) -> Self

where R: Rng + ?Sized, S: DataOwned, Ds: Clone + Distribution<A>, Sh: ShapeBuilder<Dim = D>,

Generate a random array using the given distribution and random number generator

fn init_rand<Ds>(self, distr: Ds) -> Self

where S: DataOwned, Ds: Clone + Distribution<A>, Self: Sized,

Initialize an array with random values using the given distribution and current shape

fn init_rand_with<Ds, R>(self, distr: Ds, rng: &mut R) -> Self

where R: Rng + ?Sized, S: DataOwned, Ds: Clone + Distribution<A>,

Initialize an array with random values from the current shape using the given distribution and random number generator

impl<A, S, D, E> IntoIterator for ParamsBase<S, D, Biased>

where A: Clone, D: Dimension<Smaller = E> + RemoveAxis, S: Data<Elem = A>, E: RemoveAxis,

type Item = (ArrayBase<OwnedRepr<A>, E>, ArrayBase<OwnedRepr<A>, <E as Dimension>::Smaller>)

The type of the elements being iterated over.

type IntoIter = IntoIter<<ParamsBase<S, D> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, S, D, E> IntoIterator for ParamsBase<S, D, Unbiased>

where A: Clone, D: Dimension<Smaller = E> + RemoveAxis, S: Data<Elem = A>, E: RemoveAxis,

type Item = ArrayBase<OwnedRepr<A>, E>

The type of the elements being iterated over.

type IntoIter = IntoIter<<ParamsBase<S, D, Unbiased> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A, S, D, K> PartialEq<(ArrayBase<S, D>, ArrayBase<S, <D as Dimension>::Smaller>)> for ParamsBase<S, D, K>

where A: PartialEq, D: RemoveAxis, S: Data<Elem = A>,

fn eq( &self, (weights, bias): &(ArrayBase<S, D>, ArrayBase<S, D::Smaller>), ) -> 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, S, D, K> PartialEq<(ArrayBase<S, D>, Option<ArrayBase<S, <D as Dimension>::Smaller>>)> for ParamsBase<S, D, K>

where A: PartialEq, D: RemoveAxis, S: Data<Elem = A>,

fn eq( &self, (weights, bias): &(ArrayBase<S, D>, Option<ArrayBase<S, D::Smaller>>), ) -> 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, S, D> PartialEq for ParamsBase<S, D>

where A: PartialEq, D: RemoveAxis, S: Data<Elem = A>,

fn eq(&self, other: &Self) -> 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, A, B, T, S, D, K> Predict<A> for &'a ParamsBase<S, D, K>

where A: Dot<Array<T, D>, Output = B>, B: Add<&'a ArrayBase<S, D::Smaller>, Output = B>, D: RemoveAxis, S: Data<Elem = T>, T: ComplexFloat,

type Output = B

fn predict(&self, input: &A) -> Result<Self::Output, PredictError>

impl<A, B, T, S, D, K> Predict<A> for ParamsBase<S, D, K>

where A: Dot<Array<T, D>, Output = B>, B: for<'a> Add<&'a ArrayBase<S, D::Smaller>, Output = B>, D: RemoveAxis, S: Data<Elem = T>, T: ComplexFloat,

type Output = B

fn predict(&self, input: &A) -> Result<Self::Output, PredictError>

impl<A, S, D, K> Serialize for ParamsBase<S, D, K>

where A: Serialize, D: RemoveAxis + Serialize, S: Data<Elem = A>, <D as Dimension>::Smaller: Dimension + Serialize,

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.

impl<A, S, D> Copy for ParamsBase<S, D>

where A: Copy, D: Copy + RemoveAxis, S: Copy + RawDataClone<Elem = A>, <D as Dimension>::Smaller: Copy,