Struct SimpleModel

pub struct SimpleModel<T = f64> {
    pub config: StandardModelConfig<T>,
    pub features: ModelFeatures,
    pub params: ModelParams<T>,
}

Fields

config: StandardModelConfig<T>

features: ModelFeatures

params: ModelParams<T>

Implementations

impl<T> SimpleModel<T>

pub fn new(config: StandardModelConfig<T>, features: ModelFeatures) -> Self

where T: Clone + Default,

pub const fn config(&self) -> &StandardModelConfig<T>

returns a reference to the model configuration

pub const fn config_mut(&mut self) -> &mut StandardModelConfig<T>

returns a mutable reference to the model configuration

pub const fn features(&self) -> ModelFeatures

returns the model features

pub const fn features_mut(&mut self) -> &mut ModelFeatures

returns a mutable reference to the model features

pub const fn params(&self) -> &ModelParams<T>

returns a reference to the model parameters

pub const fn params_mut(&mut self) -> &mut ModelParams<T>

returns a mutable reference to the model parameters

pub fn set_config(&mut self, config: StandardModelConfig<T>) -> &mut Self

set the current configuration and return a mutable reference to the model

pub fn set_features(&mut self, features: ModelFeatures) -> &mut Self

set the current features and return a mutable reference to the model

pub fn set_params(&mut self, params: ModelParams<T>) -> &mut Self

set the current parameters and return a mutable reference to the model

pub fn with_config(self, config: StandardModelConfig<T>) -> Self

consumes the current instance to create another with the given configuration

pub fn with_features(self, features: ModelFeatures) -> Self

consumes the current instance to create another with the given features

pub fn with_params(self, params: ModelParams<T>) -> Self

consumes the current instance to create another with the given parameters

pub fn init(self) -> Self

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

initializes the model with Glorot normal distribution

Trait Implementations

impl<T: Clone> Clone for SimpleModel<T>

fn clone(&self) -> SimpleModel<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SimpleModel<T>

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

Formats the value using the given formatter.

impl<A, S, D> Forward<ArrayBase<S, D>> for SimpleModel<A>

where A: Float + FromPrimitive + ScalarOperand, D: Dimension, S: Data<Elem = A>, Params<A>: Forward<Array<A, D>, Output = Array<A, D>>,

type Output = ArrayBase<OwnedRepr<A>, D>

fn forward(&self, input: &ArrayBase<S, D>) -> Result<Self::Output>

a single forward step

fn forward_then<F>(&self, input: &Rhs, then: F) -> Result<Self::Output, Error>

where F: FnOnce(Self::Output) -> Self::Output,

this method enables the forward pass to be generically activated using some closure. This is useful for isolating the logic of the forward pass from that of the activation function and is often used by layers and models.

impl<T> Model<T> for SimpleModel<T>

type Config = StandardModelConfig<T>

The configuration type for the model

type Layout = ModelFeatures

the type of layout used by the model

fn config(&self) -> &StandardModelConfig<T>

returns an immutable reference to the models configuration; this is typically used to access the models hyperparameters (i.e. learning rate, momentum, etc.) and other related control parameters.

fn config_mut(&mut self) -> &mut StandardModelConfig<T>

returns a mutable reference to the models configuration; useful for setting hyperparams

fn layout(&self) -> ModelFeatures

returns a copy of the model’s current layout (features); a type providing the model with a particular number of features for the various layers of a deep neural network.

fn params(&self) -> &ModelParams<T>

returns an immutable reference to the model parameters

fn params_mut(&mut self) -> &mut ModelParams<T>

returns a mutable reference to the model’s parameters

fn predict<U, V>(&self, inputs: &U) -> Result<V, NeuralError>

where Self: Predict<U, Output = V>,

propagates the input through the model; each layer is applied in sequence meaning that the output of each previous layer is the input to the next layer. This pattern repeats until the output layer returns the final result.

fn train<U, V, W>( &mut self, dataset: &DatasetBase<U, V>, ) -> Result<W, NeuralError>

where Self: Train<U, V, Output = W>,

a convience method that trains the model using the provided dataset; this method requires that the model implements the Train trait and that the dataset

impl<A, S, T> Train<ArrayBase<S, Dim<[usize; 1]>>, ArrayBase<T, Dim<[usize; 1]>>> for SimpleModel<A>

where A: Float + FromPrimitive + NumAssign + ScalarOperand + Debug, S: Data<Elem = A>, T: Data<Elem = A>,

type Output = A

fn train( &mut self, input: &ArrayBase<S, Ix1>, target: &ArrayBase<T, Ix1>, ) -> Result<Self::Output, NeuralError>

fn train_for( &mut self, input: &X, target: &Y, epochs: usize, ) -> Result<Self::Output, NeuralError>

impl<A, S, T> Train<ArrayBase<S, Dim<[usize; 2]>>, ArrayBase<T, Dim<[usize; 2]>>> for SimpleModel<A>

where A: Float + FromPrimitive + NumAssign + ScalarOperand + Debug, S: Data<Elem = A>, T: Data<Elem = A>,

type Output = A

fn train( &mut self, input: &ArrayBase<S, Ix2>, target: &ArrayBase<T, Ix2>, ) -> Result<Self::Output, NeuralError>

fn train_for( &mut self, input: &X, target: &Y, epochs: usize, ) -> Result<Self::Output, NeuralError>