Struct ModelParamsBase 

pub struct ModelParamsBase<S, D, H, A = <S as RawData>::Elem>
where
    D: Dimension,
    S: RawData<Elem = A>,
    H: RawHidden<S, D>,
{ /* private fields */ }

The ModelParamsBase object is a generic container for storing the parameters of a neural network, regardless of the layout (e.g. shallow or deep). This is made possible through the introduction of a generic hidden layer type, H, that allows us to define aliases and additional traits for contraining the hidden layer type. Additionally, the structure enables the introduction of common accessors and initialization routines.

With that in mind, we don’t reccomend using the implementation directly, rather, leverage a type alias that best suites your use case (e.g. owned parameters, arc parameters, etc.).

Implementations

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

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

The base implementation for the ModelParamsBase type, which is generic over the storage type S, the dimension D, and the hidden layer type H. This implementation focuses on providing basic initialization routines and accessors for the various layers within the model.

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

create a new instance of the ModelParamsBase instance

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) -> &H

returns an immutable reference to the hidden layers of the model

pub const fn hidden_mut(&mut self) -> &mut H

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

set the input layer of the model

pub fn set_hidden(&mut self, hidden: H)

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(self, hidden: H) -> Self

consumes the current instance and returns another with the specified hidden layer(s)

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

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

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

where H: DeepModelRepr<S, D>,

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

pub const fn input_bias(&self) -> &ArrayBase<S, D::Smaller, A>

returns an immutable reference to the input bias

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

returns a mutable reference to the input bias

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

returns an immutable reference to the input weights

pub const fn input_weights_mut(&mut self) -> &mut ArrayBase<S, D, A>

returns an mutable reference to the input weights

pub const fn output_bias(&self) -> &ArrayBase<S, D::Smaller, A>

returns an immutable reference to the output bias

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

returns a mutable reference to the output bias

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

returns an immutable reference to the output weights

pub const fn output_weights_mut(&mut self) -> &mut ArrayBase<S, D, A>

returns an mutable reference to the output weights

pub fn layers(&self) -> usize

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

pub fn count_hidden(&self) -> usize

returns the number of hidden layers in the model

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.

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

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

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

create a new instance of the ModelParamsBase instance

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

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

pub fn size(&self) -> usize

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

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 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) -> 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, Dim<[usize; 2]>, Vec<ParamsBase<S, Dim<[usize; 2]>, A>>, A>

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

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

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

create a new instance of the ModelParamsBase instance

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

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

pub fn default(input: D, hidden: D, output: D) -> Self

where A: Clone + Default, S: DataOwned, D: RemoveAxis,

initialize a new instance of the ShallowParamsBase with the given input, hidden, and output dimensions using the default values for the parameters

pub fn size(&self) -> usize

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

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

returns an immutable reference to the hidden weights

pub const fn hidden_weights_mut(&mut self) -> &mut ArrayBase<S, D, A>

returns an mutable reference to the hidden weights

impl<S, A> ModelParamsBase<S, Dim<[usize; 2]>, ParamsBase<S, Dim<[usize; 2]>, A>, A>

where S: RawData<Elem = A>,

pub fn from_features(features: ModelFeatures) -> Self

where A: Clone + Default, S: DataOwned,

pub fn forward(&self, input: &Array1<A>) -> Array1<A>

where A: Float + ScalarOperand, S: Data,

forward input through the controller network

Trait Implementations

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

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

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, H> Debug for ModelParamsBase<S, D, H, A>

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

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

Formats the value using the given formatter.

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

where D: Dimension, H: RawHidden<S, D> + Debug, S: Data<Elem = A>, A: Display,

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

Formats the value using the given formatter.

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

where D: Dimension, S: Data<Elem = A>, H: RawHidden<S, D> + Index<usize, Output = ParamsBase<S, D>>, A: Clone,

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, H> IndexMut<usize> for ModelParamsBase<S, D, H, A>

where D: Dimension, S: Data<Elem = A>, H: RawHidden<S, D> + IndexMut<usize, Output = ParamsBase<S, D>>, A: Clone,

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

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