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 fn init(self) -> Self

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

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

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

pub const fn features(&self) -> ModelFeatures

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

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

Trait Implementations

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>