Struct SurfaceModel 

pub struct SurfaceModel<A = f64> { /* private fields */ }

A multi-layer perceptron implementation

Implementations

impl<A> SurfaceModel<A>

pub fn default(config: SurfaceModelConfig<A>, features: ModelFeatures) -> Self

where A: Clone + Default,

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

pub fn ones(config: SurfaceModelConfig<A>, features: ModelFeatures) -> Self

where A: Clone + One,

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

pub fn zeros(config: SurfaceModelConfig<A>, features: ModelFeatures) -> Self

where A: Clone + Zero,

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

pub const fn attention(&self) -> Option<&FftAttention<A>>

returns an immutable reference to the attention mechanism of the model

pub const fn attention_mut(&mut self) -> Option<&mut FftAttention<A>>

returns a mutable reference to the attention mechanism of the model

pub const fn config(&self) -> &SurfaceModelConfig<A>

returns an immutable reference to the model’s configuration

pub const fn config_mut(&mut self) -> &mut SurfaceModelConfig<A>

returns a mutable reference to the model’s configuration

pub const fn features(&self) -> ModelFeatures

returns an immutable reference to the model’s features

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

returns a mutable reference to the model’s features

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

returns an immutable reference to the model’s parameters

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

returns a mutable reference to the model’s parameters

pub const fn velocities(&self) -> &ModelParams<A>

returns an immutable reference to the model’s velocities

pub const fn velocities_mut(&mut self) -> &mut ModelParams<A>

returns a mutable reference to the model’s velocities

pub const fn input(&self) -> &Params<A>

returns an immutable reference to the input layer of the model

pub const fn input_mut(&mut self) -> &mut Params<A>

returns a mutable reference to the input layer of the model

pub const fn hidden(&self) -> &Vec<Params<A>>

returns an immutable reference to the hidden layers of the model

pub const fn hidden_mut(&mut self) -> &mut Vec<Params<A>>

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

pub fn hidden_as_slice(&self) -> &[Params<A>]

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

pub const fn output(&self) -> &Params<A>

returns an immutable reference to the output layer of the model

pub const fn output_mut(&mut self) -> &mut Params<A>

returns a mutable reference to the output layer of the model

pub const fn decay(&self) -> &A

returns an immutable reference to the decay of the model

pub const fn learning_rate(&self) -> &A

returns an immutable reference to the learning rate of the model

pub const fn momentum(&self) -> &A

returns an immutable reference to the momentum of the model

pub fn set_attention(&mut self, attention: Option<FftAttention<A>>) -> &mut Self

set the model’s attention mechanism

pub fn set_config(&mut self, config: SurfaceModelConfig<A>) -> &mut Self

set the model’s configuration

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

set the model’s features

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

set the model’s parameters

pub fn set_input(&mut self, input: Params<A>) -> &mut Self

set the input layer of the model

pub fn set_hidden<I>(&mut self, iter: I) -> &mut Self

where I: IntoIterator<Item = Params<A>>,

set the hidden layers of the model

pub fn set_output(&mut self, output: Params<A>) -> &mut Self

set the output layer of the model

pub fn set_decay(&mut self, decay: A) -> &mut Self

set the decay for the model

pub fn set_learning_rate(&mut self, learning_rate: A) -> &mut Self

set the learning rate for the model

pub fn set_momentum(&mut self, momentum: A) -> &mut Self

set the model’s momentum

pub fn with_attention(self) -> Self

where A: FromPrimitive,

create a new instance of the model with the specified attention mechanism

pub fn with_config(self, config: SurfaceModelConfig<A>) -> Self

consumes the current instance and returns another with the specified configuration

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

consumes the current instance and returns another with the given features

pub fn with_input(self, input: Params<A>) -> Self

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

pub fn with_hidden<I>(self, iter: I) -> Self

where I: IntoIterator<Item = Params<A>>,

consumes the current instance and returns another with the specified hidden layers

pub fn with_output(self, output: Params<A>) -> Self

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

pub fn has_attention(&self) -> bool

returns true if the model has an attention mechanism

pub fn has_no_attention(&self) -> bool

returns true if the model has no attention mechanism

impl<A> SurfaceModel<A>

pub fn init(self) -> Self

where Self: Init,

consumes the current instance to initialize the model params

pub fn init_inplace(&mut self) -> &mut Self

where Self: InitInplace,

initialize the model params in place

impl<A> SurfaceModel<A>

where A: Float + FromPrimitive + ScalarOperand,

pub fn predict<X>( &self, input: &X, ) -> NeuralResult<<Self as Predict<X>>::Output>

where Self: Predict<X>,

predict some outcome by forward propgating the given input through the model

pub fn train<X, Y, Z>(&mut self, input: &X, target: &Y) -> NeuralResult<Z>

where Self: Train<X, Y, Output = Z>,

train the model on some input and target data by backpropagating the error through the model

Trait Implementations

impl<A: Clone> Clone for SurfaceModel<A>

fn clone(&self) -> SurfaceModel<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for SurfaceModel<A>

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

Formats the value using the given formatter.

impl<A> Default for SurfaceModel<A>

where A: Clone + Default + FromPrimitive,

fn default() -> Self

Returns the “default value” for a type.

impl<S, T> Forward<ArrayBase<S, Dim<[usize; 1]>>> for SurfaceModel<T>

where S: Data<Elem = T>, T: FftNum + Float + FromPrimitive + ScalarOperand,

type Output = ArrayBase<OwnedRepr<T>, Dim<[usize; 1]>>

fn forward(&self, input: &ArrayBase<S, Ix1>) -> 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<S, T> Forward<ArrayBase<S, Dim<[usize; 2]>>> for SurfaceModel<T>

where S: Data<Elem = T>, T: FftNum + Float + FromPrimitive + ScalarOperand,

type Output = ArrayBase<OwnedRepr<T>, Dim<[usize; 2]>>

fn forward(&self, input: &ArrayBase<S, Ix2>) -> 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<A> Init for SurfaceModel<A>

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

fn init(self) -> Self

consumes the current instance to initialize a new one

impl<A> InitInplace for SurfaceModel<A>

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

fn init_inplace(&mut self) -> &mut Self

initialize the object in-place and return a mutable reference to it.

impl<A> PartialEq for SurfaceModel<A>

where A: PartialEq, ModelParams<A>: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

type Output = A

fn train( &mut self, input: &ArrayBase<S, Ix1>, target: &ArrayBase<T, Ix1>, ) -> Result<A, 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 SurfaceModel<A>

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

type Output = A

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

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