Struct LayerBase

pub struct LayerBase<F, S, D = Ix2>
where
    D: Dimension,
    S: RawData,
{ /* private fields */ }

The LayerBase struct is a base representation of a neural network layer, essentially binding an activation function, F, to a set of parameters, ParamsBase<S, D>.

Implementations

impl<S, D> LayerBase<Linear, S, D>

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

pub const fn linear(params: ParamsBase<S, D>) -> Self

initialize a new LayerBase using a Linear activation function and the given parameters.

impl<S, D> LayerBase<Sigmoid, S, D>

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

pub const fn sigmoid(params: ParamsBase<S, D>) -> Self

initialize a new LayerBase using a Sigmoid activation function and the given parameters.

impl<S, D> LayerBase<Tanh, S, D>

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

pub const fn tanh(params: ParamsBase<S, D>) -> Self

initialize a new LayerBase using a Tanh activation function and the given parameters.

impl<S, D> LayerBase<ReLU, S, D>

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

pub const fn relu(params: ParamsBase<S, D>) -> Self

initialize a new LayerBase using a ReLU activation function and the given

impl<F, S, A, D> LayerBase<F, S, D>

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

pub const fn new(rho: F, params: ParamsBase<S, D>) -> Self

create a new LayerBase from the given activation function and parameters.

pub fn from_params(params: ParamsBase<S, D>) -> Self

where F: Default,

create a new LayerBase from the given parameters assuming the logical default for the activation of type F.

pub fn from_rho<Sh>(rho: F, shape: Sh) -> Self

where A: Clone + Default, S: DataOwned, D: RemoveAxis, Sh: ShapeBuilder<Dim = D>,

create a new LayerBase from the given activation function and shape.

pub const fn params(&self) -> &ParamsBase<S, D>

returns an immutable reference to the layer’s parameters

pub const fn params_mut(&mut self) -> &mut ParamsBase<S, D>

returns a mutable reference to the layer’s parameters

pub const fn rho(&self) -> &F

returns an immutable reference to the activation function of the layer

pub const fn rho_mut(&mut self) -> &mut F

returns a mutable reference to the activation function of the layer

pub fn with_params<S2, D2>( self, params: ParamsBase<S2, D2>, ) -> LayerBase<F, S2, D2>

where S2: RawData<Elem = S::Elem>, D2: Dimension,

consumes the current instance and returns another with the given parameters.

pub fn with_rho<G>(self, rho: G) -> LayerBase<G, S, D>

where G: Activator<S::Elem>, F: Activator<S::Elem>, S: RawData<Elem = A>,

consumes the current instance and returns another with the given activation function. This is useful during the creation of the model, when the activation function is not known yet.

pub fn forward<X, Y>(&self, input: &X) -> Result<Y>

where F: Activator<<ParamsBase<S, D> as Forward<X>>::Output, Output = Y>, ParamsBase<S, D>: Forward<X, Output = Y>, X: Clone, Y: Clone,

Methods from Deref<Target = ParamsBase<S, D>>

pub fn bias(&self) -> &ArrayBase<S, <D as Dimension>::Smaller>

returns an immutable reference to the bias

pub fn bias_mut(&mut self) -> &mut ArrayBase<S, <D as Dimension>::Smaller>

returns a mutable reference to the bias

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

returns an immutable reference to the weights

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

returns a mutable reference to the weights

pub fn assign_bias( &mut self, bias: &ArrayBase<S, <D as Dimension>::Smaller>, ) -> &mut ParamsBase<S, D>

where A: Clone, S: DataMut,

assign the bias

pub fn assign_weights( &mut self, weights: &ArrayBase<S, D>, ) -> &mut ParamsBase<S, D>

where A: Clone, S: DataMut,

assign the weights

pub fn replace_bias( &mut self, bias: ArrayBase<S, <D as Dimension>::Smaller>, ) -> ArrayBase<S, <D as Dimension>::Smaller>

replace the bias and return the previous state; uses replace

pub fn replace_weights(&mut self, weights: ArrayBase<S, D>) -> ArrayBase<S, D>

replace the weights and return the previous state; uses replace

pub fn set_bias( &mut self, bias: ArrayBase<S, <D as Dimension>::Smaller>, ) -> &mut ParamsBase<S, D>

set the bias

pub fn set_weights(&mut self, weights: ArrayBase<S, D>) -> &mut ParamsBase<S, D>

set the weights

pub fn backward<X, Y, Z>( &mut self, input: &X, grad: &Y, lr: A, ) -> Result<Z, Error>

where A: Clone, S: Data, ParamsBase<S, D>: Backward<X, Y, Elem = A, Output = Z>,

perform a single backpropagation step

pub fn forward<X, Y>(&self, input: &X) -> Result<Y, Error>

where A: Clone, S: Data, ParamsBase<S, D>: Forward<X, Output = Y>,

forward propagation

pub fn dim(&self) -> <D as Dimension>::Pattern

returns the dimensions of the weights

pub fn is_empty(&self) -> bool

returns true if both the weights and bias are empty; uses is_empty

pub fn is_weights_empty(&self) -> bool

returns true if the weights are empty

pub fn is_bias_empty(&self) -> bool

returns true if the bias is empty

pub fn count_weight(&self) -> usize

the total number of elements within the weight tensor

pub fn count_bias(&self) -> usize

the total number of elements within the bias tensor

pub fn raw_dim(&self) -> D

returns the raw dimensions of the weights;

pub fn shape(&self) -> &[usize]

returns the shape of the parameters; uses the shape of the weight tensor

pub fn shape_bias(&self) -> &[usize]

returns the shape of the bias tensor; the shape should be equivalent to that of the weight tensor minus the “zero-th” axis

pub fn size(&self) -> usize

returns the total number of parameters within the layer

pub fn to_owned(&self) -> ParamsBase<OwnedRepr<A>, D>

where A: Clone, S: DataOwned,

returns an owned instance of the parameters

pub fn to_shape<Sh>( &self, shape: Sh, ) -> Result<ParamsBase<CowRepr<'_, A>, <Sh as ShapeBuilder>::Dim>, Error>

where A: Clone, S: DataOwned, Sh: ShapeBuilder, <Sh as ShapeBuilder>::Dim: Dimension + RemoveAxis,

change the shape of the parameters; the shape of the bias parameters is determined by removing the “zero-th” axis of the given shape

pub fn to_shared(&self) -> ParamsBase<OwnedArcRepr<A>, D>

where A: Clone, S: Data,

returns a new ParamsBase instance with the same paramaters, but using a shared representation of the data;

pub fn view(&self) -> ParamsBase<ViewRepr<&A>, D>

where S: Data,

returns a “view” of the parameters; see view for more information

pub fn view_mut(&mut self) -> ParamsBase<ViewRepr<&mut A>, D>

where S: DataMut,

returns mutable view of the parameters; see view_mut for more information

pub fn ncols(&self) -> usize

returns the number of columns in the weights matrix

pub fn nrows(&self) -> usize

returns the number of rows in the weights matrix

pub fn iter(&self) -> Iter<'_, A, D>

where D: RemoveAxis, S: Data,

an iterator of the parameters; the created iterator zips together an axis iterator over the columns of the weights and an iterator over the bias

pub fn iter_mut(&mut self) -> IterMut<'_, A, D>

where D: RemoveAxis, S: DataMut,

returns a mutable iterator of the parameters, IterMut, which essentially zips together a mutable axis iterator over the columns of the weights against a mutable iterator over the elements of the bias

pub fn iter_bias(&self) -> Iter<'_, A, <D as Dimension>::Smaller>

where S: Data,

returns an iterator over the bias

pub fn iter_bias_mut(&mut self) -> IterMut<'_, A, <D as Dimension>::Smaller>

where S: DataMut,

returns a mutable iterator over the bias

pub fn iter_weights(&self) -> Iter<'_, A, D>

where S: Data,

returns an iterator over the weights

pub fn iter_weights_mut(&mut self) -> IterMut<'_, A, D>

where S: DataMut,

returns a mutable iterator over the weights; see iter_mut for more

pub fn l1_norm(&self) -> A

Returns the L1 norm of the parameters (bias and weights).

pub fn l2_norm(&self) -> A

Returns the L2 norm of the parameters (bias and weights).

pub fn apply_gradient<Delta, Z>( &mut self, grad: &Delta, lr: A, ) -> Result<Z, Error>

where S: DataMut, ParamsBase<S, D>: ApplyGradient<Delta, A, Output = Z>,

a convenience method used to apply a gradient to the parameters using the given learning rate.

pub fn apply_gradient_with_decay<Grad, Z>( &mut self, grad: &Grad, lr: A, decay: A, ) -> Result<Z, Error>

where S: DataMut, ParamsBase<S, D>: ApplyGradient<Grad, A, Output = Z>,

pub fn apply_gradient_with_momentum<Grad, V, Z>( &mut self, grad: &Grad, lr: A, momentum: A, velocity: &mut V, ) -> Result<Z, Error>

where S: DataMut, ParamsBase<S, D>: ApplyGradientExt<Grad, A, Output = Z, Velocity = V>,

pub fn apply_gradient_with_decay_and_momentum<Grad, V, Z>( &mut self, grad: &Grad, lr: A, decay: A, momentum: A, velocity: &mut V, ) -> Result<Z, Error>

where S: DataMut, ParamsBase<S, D>: ApplyGradientExt<Grad, A, Output = Z, Velocity = V>,

Trait Implementations

impl<U, V, F, S, D> Activator<U> for LayerBase<F, S, D>

where F: Activator<U, Output = V>, D: Dimension, S: RawData,

type Output = V

fn activate(&self, x: U) -> Self::Output

Applies the activation function to the input tensor.

impl<U, F, S, D> ActivatorGradient<U> for LayerBase<F, S, D>

where F: ActivatorGradient<U>, D: Dimension, S: RawData,

type Input = <F as ActivatorGradient<U>>::Input

type Delta = <F as ActivatorGradient<U>>::Delta

fn activate_gradient(&self, inputs: F::Input) -> F::Delta

compute the gradient of some input

impl<F, S, D> Deref for LayerBase<F, S, D>

where D: Dimension, S: RawData,

type Target = ParamsBase<S, D>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F, S, D> DerefMut for LayerBase<F, S, D>

where D: Dimension, S: RawData,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<A, X, Y, F, S, D> Forward<X> for LayerBase<F, S, D>

where A: Clone, F: Activator<Y, Output = Y>, D: Dimension, S: Data<Elem = A>, ParamsBase<S, D>: Forward<X, Output = Y>,

type Output = Y

fn forward(&self, inputs: &X) -> 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, F, S, D> Layer<S, D> for LayerBase<F, S, D>

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

type Elem = A

the type of element used within the layer; typically a floating-point variant like f32 or f64.

type Rho = F

The type of activator used by the layer; the type must implement ActivatorGradient

fn rho(&self) -> &Self::Rho

fn params(&self) -> &ParamsBase<S, D>

returns an immutable reference to the parameters of the layer

fn params_mut(&mut self) -> &mut ParamsBase<S, D>

returns a mutable reference to the parameters of the layer