Struct ModelParamsBase

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

The ModelParamsBase object is a generic ocntainer 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. That being said, we don’t reccoment using this type directly, but rather use the provided type aliases such as DeepModelParams or ShallowModelParams or their owned variants. These provide a much more straighforward interface for typing the parameters of a neural network. We aren’t too worried about the transumtation between the two since users desiring this ability should simply stick with a deep representation, initializing only a single layer within the respective container.

This type also enables us to define a set of common initialization routines and introduce other standards for dealing with parameters in a neural network.

Implementations

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

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

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

set the input layer of the model

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

set the hidden layers of the model

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(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: DeepNeuralStore<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>

returns an immutable reference to the input bias

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

returns a mutable reference to the input bias

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

returns an immutable reference to the input weights

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

returns an mutable reference to the input weights

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

returns an immutable reference to the output bias

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

returns a mutable reference to the output bias

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

returns an immutable reference to the output weights

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

returns an mutable reference to the output weights

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.

pub fn len(&self) -> usize

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

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

where D: Dimension, S: RawData<Elem = A>, H: DeepNeuralStore<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>>>

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

where D: Dimension, S: RawData<Elem = A>, H: ShallowNeuralStore<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>>

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>

returns an immutable reference to the hidden weights

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

returns an mutable reference to the hidden weights

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

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>) -> Result<Array1<A>>

where A: Float + ScalarOperand, S: Data,

forward input through the controller network

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

where S: DataOwned<Elem = A>,

pub fn init(self) -> Self

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

consumes the controller to initialize the various parameters with random values

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: Float + FromPrimitive + SampleUniform, <A as SampleUniform>::Sampler: Clone, Uniform<A>: Distribution<A>,

initialize the model parameters using a glorot uniform distribution

impl<A, S> ModelParamsBase<S, Dim<[usize; 2]>, Vec<ParamsBase<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, H> Clone for ModelParamsBase<S, D, H>

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

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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, A, S, D, H> Deserialize<'a> for ModelParamsBase<S, D, H>

where A: Deserialize<'a>, D: Dimension + Deserialize<'a>, S: DataOwned<Elem = A>, H: RawHidden<S, D> + Deserialize<'a>, <D as Dimension>::Smaller: Deserialize<'a>,

fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>

where De: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

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

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>

where D: Dimension, S: Data<Elem = A>, H: DeepNeuralStore<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>

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

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

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

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

where A: Serialize, D: Dimension + Serialize, S: Data<Elem = A>, H: RawHidden<S, D> + Serialize, <D as Dimension>::Smaller: Serialize,

fn serialize<Se>(&self, serializer: Se) -> Result<Se::Ok, Se::Error>

where Se: Serializer,

Serialize this value into the given Serde serializer.