Struct LayerBase 

pub struct LayerBase<F, P> {
    pub rho: F,
    pub params: P,
}

The LayerBase implementation works to provide a generic interface for layers within a neural network by associating an activation function F with a set of parameters P.

Fields

rho: F

the activation function of the layer

params: P

the parameters of the layer; often weights and biases

Implementations

impl<F, P, A> LayerBase<F, P>

where P: RawParams<Elem = A>,

pub const fn new(rho: F, params: P) -> Self

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

pub fn from_params(params: P) -> 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) -> Self

where P: Default,

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

pub const fn params(&self) -> &P

returns an immutable reference to the layer’s parameters

pub const fn params_mut(&mut self) -> &mut P

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<Y>(self, params: Y) -> LayerBase<F, Y>

where F: Activator<Y>,

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

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

where G: Activator<P>,

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 activate<X, Y>(&self, input: X) -> Y

where F: Activator<X, Output = Y>,

apply the configured activation function onto some input, producing some output

pub fn forward<U, V>(&self, input: &U) -> V

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

given some input, complete a single forward pass through the layer

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

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

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

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

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

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

pub fn raw_dim(&self) -> D

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

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

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

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

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

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

pub const fn bias(&self) -> &ArrayBase<S, E, A>

pub const fn bias_mut(&mut self) -> &mut ArrayBase<S, E, A>

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

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

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

pub fn raw_dim(&self) -> D

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

impl<A, P> LayerBase<Linear, P>

where P: RawParams<Elem = A>,

pub const fn linear(params: P) -> Self

initialize a layer using the Linear activation function and the given params.

impl<A, P> LayerBase<Sigmoid, P>

where P: RawParams<Elem = A>,

pub const fn sigmoid(params: P) -> Self

initialize a layer using the Sigmoid activation function and the given params.

impl<A, P> LayerBase<HyperbolicTangent, P>

where P: RawParams<Elem = A>,

pub const fn tanh(params: P) -> Self

initialize a new layer using a [TanhActivator] activation function and the given parameters.

impl<A, P> LayerBase<ReLU, P>

where P: RawParams<Elem = A>,

pub const fn relu(params: P) -> Self

initialize a layer using the Sigmoid activation function and the given params.

Trait Implementations

impl<F, P, A, X, Y> Activator<X> for LayerBase<F, P>

where F: Activator<X, Output = Y>, P: RawParams<Elem = A>,

type Output = <F as Activator<X>>::Output

fn activate(&self, input: X) -> Self::Output

Applies the activation function to the input tensor.

impl<F: Clone, P: Clone> Clone for LayerBase<F, P>

fn clone(&self) -> LayerBase<F, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug, P: Debug> Debug for LayerBase<F, P>

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

Formats the value using the given formatter.

impl<F: Default, P: Default> Default for LayerBase<F, P>

fn default() -> LayerBase<F, P>

Returns the “default value” for a type.

impl<F, P, A, X, Y, Z> Forward<X> for LayerBase<F, P>

where F: Activator<Y, Output = Z>, P: RawParams<Elem = A> + Forward<X, Output = Y>,

type Output = <F as Activator<Y>>::Output

fn forward(&self, input: &X) -> Self::Output

a single forward step

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

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<F: Hash, P: Hash> Hash for LayerBase<F, P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: Ord, P: Ord> Ord for LayerBase<F, P>

fn cmp(&self, other: &LayerBase<F, P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<F: PartialEq, P: PartialEq> PartialEq for LayerBase<F, P>

fn eq(&self, other: &LayerBase<F, P>) -> 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<F: PartialOrd, P: PartialOrd> PartialOrd for LayerBase<F, P>

fn partial_cmp(&self, other: &LayerBase<F, P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F, P, A> RawLayer<F, A> for LayerBase<F, P>

where F: Activator<A>, P: RawParams<Elem = A>,

type Params<_T> = P

fn rho(&self) -> &F

the activation function of the layer

fn params(&self) -> &P

returns an immutable reference to the parameters of the layer

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

where F: Activator<Y, Output = Z>, Self::Params<A>: Forward<X, Output = Y>,

complete a forward pass through the layer

impl<F, P, A> RawLayerMut<F, A> for LayerBase<F, P>

where F: Activator<A>, P: RawParams<Elem = A>,

fn params_mut(&mut self) -> &mut P

returns a mutable reference to the parameters of the layer

fn backward<X, Y, Z, Dt>(&mut self, input: X, error: Y, gamma: A)

where A: Clone, F: ActivatorGradient<Y, Rel = F, Delta = Dt>, Self::Params<A>: Backward<X, Dt, Elem = A>,

backward propagate error through the layer

fn set_params(&mut self, params: Self::Params<A>)

update the layer parameters

fn replace_params(&mut self, params: Self::Params<A>) -> Self::Params<A>

replace the params of the layer, returning the previous value

fn swap_params(&mut self, other: &mut Self::Params<A>)

swap the params of the layer with another

impl<F: Eq, P: Eq> Eq for LayerBase<F, P>

impl<F, P> StructuralPartialEq for LayerBase<F, P>