Struct ModelParamsBase 

pub struct ModelParamsBase<S, D = Dim<[usize; 2]>>
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>, ) -> ModelParamsBase<S, D>

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

set the input layer of the model

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

set the hidden layers of the model

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

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

set the output layer of the model

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

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

pub fn with_hidden<I>(self, iter: I) -> ModelParamsBase<S, D>

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>) -> ModelParamsBase<S, D>

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 as SliceIndex<[ParamsBase<S, D>]>>::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 as SliceIndex<[ParamsBase<S, D>]>>::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, Error>

where A: Clone, S: Data, ParamsBase<S, D>: Forward<X, Output = Y, Output = Y> + Forward<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) -> ModelParamsBase<S>

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) -> ModelParamsBase<S>

where A: Clone + One, S: DataOwned,

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

pub fn zeros(features: ModelFeatures) -> ModelParamsBase<S>

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) -> ModelParamsBase<S>

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) -> ModelParamsBase<S>

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

initialize the model parameters using a glorot normal distribution

pub fn glorot_uniform(features: ModelFeatures) -> ModelParamsBase<S>

where A: Clone + Float + FromPrimitive + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone, Uniform<<S as RawData>::Elem>: Distribution<<S as RawData>::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) -> ModelParamsBase<S, D>

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<(), Error>

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<(), Error>

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, ) -> &<ModelParamsBase<S, D> as Index<usize>>::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 <ModelParamsBase<S, D> as Index<usize>>::Output

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