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, HParam = 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<Grad, Z>(&mut self, grad: &Grad, lr: A) -> Result<Z>

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

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

where S: DataMut, Self: 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>

where S: DataMut, Self: 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>

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

Trait Implementations

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

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

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>, A> 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>

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

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

type Data = S

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,

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,