Struct ModelParamsBase

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

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.

Implementations

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

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

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

returns a new instance of the ModelParamsBase with the specified input, hidden, and output layers.

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

returns an immutable reference to the input layer of the model

pub const 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 const 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 const 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>) -> &mut Self

set the input layer of the model

pub fn set_hidden(&mut self, hidden: Vec<ParamsBase<S, D>>) -> &mut Self

set the hidden layers of the model

pub fn set_hidden_layer( &mut self, idx: usize, layer: ParamsBase<S, D>, ) -> &mut Self

set the layer at the specified index in the hidden layers of the model

Panics

Panics if the index is out of bounds or if the dimension of the provided layer is inconsistent with the others in the stack.

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

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 get_hidden_layer<I>(&self, idx: I) -> Option<&I::Output>

where I: SliceIndex<[ParamsBase<S, D>]>,

returns the hidden layer associated with the given index

pub fn get_hidden_layer_mut<I>(&mut self, idx: I) -> Option<&mut I::Output>

where I: SliceIndex<[ParamsBase<S, D>]>,

returns a mutable reference to the hidden layer associated with the given index

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

pub fn is_shallow(&self) -> bool

returns true if the stack is shallow; a neural network is considered to be shallow if it has at most one hidden layer (n <= 1).

pub fn is_deep(&self) -> bool

returns true if the model stack of parameters is considered to be deep, meaning that there the number of hidden layers is greater than one.

pub fn count_hidden(&self) -> usize

returns the total number of hidden layers within the model

pub fn len(&self) -> usize

returns the total number of layers within the model, including the input and output layers

pub fn size(&self) -> usize

returns the total number parameters within the model, including the input and output layers

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

impl<A, S> ModelParamsBase<S>

where S: DataOwned<Elem = A>,

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

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

returns a new instance of the model initialized with the given features and random distribution

pub fn glorot_normal(features: ModelFeatures) -> Self

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

initialize the model parameters using a glorot normal distribution

pub fn glorot_uniform(features: ModelFeatures) -> Self

where 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.