Struct ModelParamsBase

pub struct ModelParamsBase<S, D = Ix2>
where
    D: Dimension,
    S: RawData,
{
    pub input: ParamsBase<S, D>,
    pub hidden: Vec<ParamsBase<S, D>>,
    pub output: ParamsBase<S, D>,
}

This object is an abstraction over the parameters of a deep neural network model. This is done to isolate the necessary parameters from the specific logic within a model allowing us to easily create additional stores for tracking velocities, gradients, and other metrics we may need.

Additionally, this provides us with a way to introduce common creation routines for initializing neural networks.

Fields

input: ParamsBase<S, D>

the input layer of the model

hidden: Vec<ParamsBase<S, D>>

a sequential stack of params for the model’s hidden layers

output: ParamsBase<S, D>

the output layer of the model

Implementations

impl<A, S, D> ModelParamsBase<S, D>

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

pub fn new( input: ParamsBase<S, D>, hidden: Vec<ParamsBase<S, D>>, output: ParamsBase<S, D>, ) -> Self

pub fn is_shallow(&self) -> bool

returns true if the stack is shallow

pub const fn input(&self) -> &ParamsBase<S, D>

returns an immutable reference to the input layer of the model

pub fn input_mut(&mut self) -> &mut ParamsBase<S, D>

returns a mutable reference to the input layer of the model

pub const fn hidden(&self) -> &Vec<ParamsBase<S, D>>

returns an immutable reference to the hidden layers of the model

pub fn hidden_as_slice(&self) -> &[ParamsBase<S, D>]

returns an immutable reference to the hidden layers of the model as a slice

pub fn hidden_mut(&mut self) -> &mut Vec<ParamsBase<S, D>>

returns a mutable reference to the hidden layers of the model

pub const fn output(&self) -> &ParamsBase<S, D>

returns an immutable reference to the output layer of the model

pub fn output_mut(&mut self) -> &mut ParamsBase<S, D>

returns a mutable reference to the output layer of the model

pub fn set_input(&mut self, input: ParamsBase<S, D>)

set the input layer of the model

pub fn set_hidden<I>(&mut self, iter: I)

where I: IntoIterator<Item = ParamsBase<S, D>>,

set the hidden layers of the model

pub fn set_output(&mut self, output: ParamsBase<S, D>)

set the output layer of the model

pub fn with_input(self, input: ParamsBase<S, D>) -> Self

consumes the current instance and returns another with the specified input layer

pub fn with_hidden<I>(self, iter: I) -> Self

where I: IntoIterator<Item = ParamsBase<S, D>>,

consumes the current instance and returns another with the specified hidden layers

pub fn with_output(self, output: ParamsBase<S, D>) -> Self

consumes the current instance and returns another with the specified output layer

pub fn dim_input(&self) -> <D as Dimension>::Pattern

returns the dimension of the input layer

pub fn dim_hidden(&self) -> <D as Dimension>::Pattern

returns the dimension of the hidden layers

pub fn dim_output(&self) -> <D as Dimension>::Pattern

returns the dimension of the output layer

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

where A: Clone, S: Data, ParamsBase<S, D>: Forward<X, Output = Y> + Forward<Y, Output = Y>,

sequentially forwards the input through the model without any activations or other complexities in-between. not overly usefuly, but it is here for completeness

impl<A, S> ModelParamsBase<S>

where S: RawData<Elem = A>,

pub fn default(features: ModelFeatures) -> Self

where A: Clone + Default, S: DataOwned,

create a new instance of the model; all parameters are initialized to their defaults (i.e., zero)

pub fn ones(features: ModelFeatures) -> Self

where A: Clone + One, S: DataOwned,

create a new instance of the model; all parameters are initialized to zero

pub fn zeros(features: ModelFeatures) -> Self

where A: Clone + Zero, S: DataOwned,

create a new instance of the model; all parameters are initialized to zero

pub fn init_rand<G, Ds>(features: ModelFeatures, distr: G) -> Self

where G: Fn((usize, usize)) -> Ds, Ds: Clone + Distribution<A>, S: DataOwned,

pub fn glorot_normal(features: ModelFeatures) -> Self

where S: DataOwned, A: Float + FromPrimitive, StandardNormal: Distribution<A>,

initialize the model parameters using a glorot normal distribution

pub fn glorot_uniform(features: ModelFeatures) -> Self

where S: DataOwned, A: Clone + Float + FromPrimitive + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone, Uniform<S::Elem>: Distribution<S::Elem>,

initialize the model parameters using a glorot uniform distribution

Trait Implementations

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

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, S, D> Debug for ModelParamsBase<S, D>

where A: Debug, D: Dimension, S: Data<Elem = A>,

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

Formats the value using the given formatter.

impl<A, S, D> Display for ModelParamsBase<S, D>

where A: Debug, D: Dimension, S: Data<Elem = A>,

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

Formats the value using the given formatter.

impl<A, S, D> Index<usize> for ModelParamsBase<S, D>

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

type Output = ParamsBase<S, D>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, S, D> IndexMut<usize> for ModelParamsBase<S, D>

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

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.