Struct ParamsBase

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

this structure extends the ArrayBase type to include bias

Implementations

impl<A, S, D> ParamsBase<S, D>

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

pub fn new(bias: ArrayBase<S, D::Smaller>, weights: ArrayBase<S, D>) -> Self

where A: Clone, S: DataOwned,

pub fn from_elems<Sh>(shape: Sh, elem: A) -> Self

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

pub fn default<Sh>(shape: Sh) -> Self

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

create an instance of the parameters with all values set to the default value

pub fn ones<Sh>(shape: Sh) -> Self

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

initialize the parameters with all values set to zero

pub fn zeros<Sh>(shape: Sh) -> Self

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

create an instance of the parameters with all values set to zero

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

returns an immutable reference to the bias

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

returns a mutable reference to the bias

pub const 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 backward<X, Y, Z>(&mut self, input: &X, grad: &Y, lr: A) -> Result<Z>

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

perform a single backpropagation step

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

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

forward propagation

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

returns the dimensions of the weights

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, ) -> Zip<AxisIterMut<'_, A, D::Smaller>, IterMut<'_, A, D::Smaller>>

where D: RemoveAxis, S: DataMut,

a mutable iterator of the parameters

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

where S: Data,

returns an iterator over the bias

pub fn iter_bias_mut(&mut self) -> IterMut<'_, A, D::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 len(&self) -> usize

the total number of elements within the weight 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 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::Dim>>

where A: Clone, S: DataOwned, Sh: ShapeBuilder, Sh::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 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

impl<A, S> ParamsBase<S, Ix1>

where S: RawData<Elem = A>,

pub fn from_scalar_bias(bias: A, weights: ArrayBase<S, Ix1>) -> Self

where A: Clone, S: DataOwned,

pub fn nrows(&self) -> usize

impl<A, S> ParamsBase<S, Ix2>

where S: RawData<Elem = A>,

pub fn ncols(&self) -> usize

pub fn nrows(&self) -> usize

impl<A, S, D> ParamsBase<S, D>

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

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>

where S: DataMut, Self: ApplyGradient<Delta, Elem = 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>

where S: DataMut, Self: ApplyGradient<Grad, Elem = 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>

where S: DataMut, Self: ApplyGradientExt<Grad, Elem = 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>

where S: DataMut, Self: ApplyGradientExt<Grad, Elem = A, Output = Z, Velocity = V>,

Trait Implementations

impl<A, S, T, D> ApplyGradient<ParamsBase<T, D>> for ParamsBase<S, D>

where A: Float + FromPrimitive + ScalarOperand, S: DataMut<Elem = A>, T: Data<Elem = A>, D: Dimension,

type Elem = A

type Output = ()

fn apply_gradient( &mut self, grad: &ParamsBase<T, D>, lr: A, ) -> Result<Self::Output>

fn apply_gradient_with_decay( &mut self, grad: &ParamsBase<T, D>, lr: A, decay: A, ) -> Result<Self::Output>

impl<A, S, T, D> ApplyGradientExt<ParamsBase<T, D>> for ParamsBase<S, D>

where A: Float + FromPrimitive + ScalarOperand, S: DataMut<Elem = A>, T: Data<Elem = A>, D: Dimension,

type Velocity = ParamsBase<OwnedRepr<A>, D>

fn apply_gradient_with_momentum( &mut self, grad: &ParamsBase<T, D>, lr: A, momentum: A, velocity: &mut Self::Velocity, ) -> Result<()>

fn apply_gradient_with_decay_and_momentum( &mut self, grad: &ParamsBase<T, D>, lr: A, decay: A, momentum: A, velocity: &mut Self::Velocity, ) -> Result<()>

impl<A, S, D> Clone for ParamsBase<S, D>

where D: Dimension, S: RawDataClone<Elem = A>, A: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, S, D> Debug for ParamsBase<S, D>

where D: Dimension, S: Data<Elem = A>, A: Debug,

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

Formats the value using the given formatter.

impl<A, X, Y, Z, S, D> Forward<X> for ParamsBase<S, D>

where A: Clone, D: Dimension, S: Data<Elem = A>, for<'a> X: Dot<ArrayBase<S, D>, Output = Y>, Y: for<'a> Add<&'a ArrayBase<S, D::Smaller>, Output = Z>,

type Output = Z

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

a single forward step

fn forward_then<F>(&self, input: &Rhs, then: F) -> Result<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<A, S, D> Initialize<S, D> for ParamsBase<S, D>

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

fn rand<Sh, Ds>(shape: Sh, distr: Ds) -> Self

where Ds: Distribution<A>, Sh: ShapeBuilder<Dim = D>, S: DataOwned,

fn rand_with<Sh, Ds, R>(shape: Sh, distr: Ds, rng: &mut R) -> Self

where R: Rng + ?Sized, Ds: Distribution<A>, Sh: ShapeBuilder<Dim = D>, S: DataOwned,

fn bernoulli<Sh>(shape: Sh, p: f64) -> Result<Self, BernoulliError>

where Bernoulli: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

fn glorot_normal<Sh>(shape: Sh, inputs: usize, outputs: usize) -> Self

where S::Elem: Float + FromPrimitive, StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Initialize the object according to the Glorot Initialization scheme.

fn glorot_uniform<Sh>( shape: Sh, inputs: usize, outputs: usize, ) -> UniformResult<Self>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Float + FromPrimitive + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone,

Initialize the object according to the Glorot Initialization scheme.

fn lecun_normal<Sh>(shape: Sh) -> Self

where StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Float,

Initialize the object according to the Lecun Initialization scheme. LecunNormal distributions are truncated Normal distributions centered at 0 with a standard deviation equal to the square root of the reciprocal of the number of inputs.

fn normal<Sh>( shape: Sh, mean: S::Elem, std: S::Elem, ) -> Result<Self, NormalError>

where StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Float,

Given a shape, mean, and standard deviation generate a new object using the Normal distribution

fn randc<Sh>(shape: Sh, re: S::Elem, im: S::Elem) -> Self

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, ComplexDistribution<S::Elem, S::Elem>: Distribution<S::Elem>,

fn stdnorm<Sh>(shape: Sh) -> Self

where StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Generate a random array using the StandardNormal distribution

fn stdnorm_from_seed<Sh>(shape: Sh, seed: u64) -> Self

where StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Generate a random array using the StandardNormal distribution with a given seed

fn truncnorm<Sh>( shape: Sh, mean: S::Elem, std: S::Elem, ) -> Result<Self, NormalError>

where StandardNormal: Distribution<S::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Float,

Initialize the object using the TruncatedNormal distribution

fn uniform<Sh>(shape: Sh, dk: S::Elem) -> UniformResult<Self>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Clone + Neg<Output = S::Elem> + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values bounded by +/- dk

fn uniform_from_seed<Sh>( shape: Sh, start: S::Elem, stop: S::Elem, key: u64, ) -> UniformResult<Self>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, S::Elem: Clone + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone,

randomly initialize the object using the Uniform distribution with values between the start and stop params using some random seed.

fn uniform_along<Sh>(shape: Sh, axis: usize) -> UniformResult<Self>

where Sh: ShapeBuilder<Dim = D>, S: DataOwned, S::Elem: Float + FromPrimitive + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values bounded by the size of the specified axis. The values are bounded by +/- dk where dk = 1 / size(axis).

fn uniform_between<Sh>(shape: Sh, a: S::Elem, b: S::Elem) -> UniformResult<Self>

where Sh: ShapeBuilder<Dim = D>, S: DataOwned, S::Elem: Clone + SampleUniform, <S::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values between then given bounds, a and b.

impl<A, S, D> PartialEq for ParamsBase<S, D>

where D: Dimension, S: Data<Elem = A>, 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, D> Copy for ParamsBase<S, D>

where D: Dimension + Copy, <D as Dimension>::Smaller: Copy, S: RawDataClone<Elem = A> + Copy, A: Copy,

impl<A, S, D> Eq for ParamsBase<S, D>

where D: Dimension, S: Data<Elem = A>, A: Eq,