Struct concision_linear::params::LinearParamsBase

pub struct LinearParamsBase<S, D = Ix2>
where
    D: RemoveAxis,
    S: RawData,
{ /* private fields */ }

Implementations

impl<A, S, D> LinearParamsBase<S, D>

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

pub fn default<Sh>(biased: bool, shape: Sh) -> LinearParamsBase<S, D>

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

pub fn ones<Sh>(biased: bool, shape: Sh) -> LinearParamsBase<S, D>

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

pub fn zeros<Sh>(biased: bool, shape: Sh) -> LinearParamsBase<S, D>

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

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

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

pub fn biased<F>(self, builder: F) -> Self

where F: Fn(D::Smaller) -> ArrayBase<S, D::Smaller>,

pub fn unbiased(self) -> Self

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

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

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

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

pub fn features(&self) -> Features

pub fn inputs(&self) -> usize

pub fn is_biased(&self) -> bool

pub fn linear<T, B>(&self, data: &T) -> B

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

pub fn ndim(&self) -> usize

pub fn outputs(&self) -> usize

pub fn raw_dim(&self) -> D

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

impl<A, S> LinearParamsBase<S>

where S: RawData<Elem = A>,

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

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

impl<A, S, D> LinearParamsBase<S, D>

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>,

impl<A, D> LinearParamsBase<OwnedRepr<A>, D>

where A: Float + SampleUniform, D: RemoveAxis, StandardNormal: Distribution<A>,

pub fn init_uniform(self, biased: bool) -> Self

pub fn init_bias(self) -> Self

pub fn init_weight(self) -> Self

pub fn uniform(self) -> Self

Trait Implementations

impl<A, S, D> Biased for LinearParamsBase<S, D>

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

type Bias = ArrayBase<S, <D as Dimension>::Smaller>

fn bias(&self) -> &Self::Bias

Returns an owned reference to the bias of the layer.

fn bias_mut(&mut self) -> &mut Self::Bias

Returns a mutable reference to the bias of the layer.

fn set_bias(&mut self, bias: Self::Bias)

Sets the bias of the layer.

impl<T, D> Borrow<LinearParamsBase<OwnedRepr<T>, D>> for Linear<T, D>

where D: RemoveAxis,

fn borrow(&self) -> &LinearParams<T, D>

Immutably borrows from an owned value.

impl<T, D> BorrowMut<LinearParamsBase<OwnedRepr<T>, D>> for Linear<T, D>

where D: RemoveAxis,

fn borrow_mut(&mut self) -> &mut LinearParams<T, D>

Mutably borrows from an owned value.

impl<A, S, D> Clone for LinearParamsBase<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, A, S, D> Deserialize<'a> for LinearParamsBase<S, D>

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 LinearParamsBase<OwnedRepr<A>, Ix1>

where A: Clone,

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

Converts to this type from the input type.

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

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 LinearParamsBase<S, D>

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> From<(ArrayBase<S, D>, Option<ArrayBase<S, <D as Dimension>::Smaller>>)> for LinearParamsBase<S, D>

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 LinearParamsBase<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> IntoIterator for LinearParamsBase<S>

where A: Clone, S: Data<Elem = A>,

type Item = (ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>, Option<ArrayBase<OwnedRepr<A>, Dim<[usize; 0]>>>)

The type of the elements being iterated over.

type IntoIter = IntoIter<<LinearParamsBase<S> 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> PartialEq<(ArrayBase<S, D>, ArrayBase<S, <D as Dimension>::Smaller>)> for LinearParamsBase<S, D>

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

fn eq( &self, (weights, bias): &(ArrayBase<S, D>, ArrayBase<S, D::Smaller>) ) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

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

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

fn eq( &self, (weights, bias): &(ArrayBase<S, D>, Option<ArrayBase<S, D::Smaller>>) ) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<A, S, D> PartialEq for LinearParamsBase<S, D>

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

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method 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> Predict<A> for &'a LinearParamsBase<S, D>

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

type Output = B

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

impl<A, B, T, S, D> Predict<A> for LinearParamsBase<S, D>

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> Serialize for LinearParamsBase<S, D>

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> Weighted for LinearParamsBase<S, D>

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

type Weight = ArrayBase<S, D>

fn weights(&self) -> &Self::Weight

Returns an owned reference to the weights of the layer.

fn weights_mut(&mut self) -> &mut Self::Weight

Returns a mutable reference to the weights of the layer.

fn set_weights(&mut self, weights: Self::Weight)

Sets the weights of the layer.

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

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