Struct dfdx::nn::Linear

pub struct Linear<const I: usize, const O: usize> {
    pub weight: Tensor2D<I, O, NoTape>,
    pub bias: Tensor1D<O, NoTape>,
}

A linear transformation of the form xW + b, where W is a matrix, x is a vector or matrix, and b is a vector. If x is a matrix this does matrix multiplication.

Implements Module for both vectors of size [I] and batches of vectors of size [B, I]. Implements Randomize to set weight & bias to random numbers drawn from a distribution.

Example usage: Linear<5, 2> can act on vectors with 5 elements, and results in vectors with 2 elements.

let model: Linear<5, 2> = Default::default();
assert_eq!(model.weight.data(), &[[0.0; 2]; 5]);
assert_eq!(model.bias.data(), &[0.0; 2]);
let x: Tensor1D<5> = Default::default();
let y: Tensor1D<2> = model.forward(x);

Fields

weight: Tensor2D<I, O, NoTape>

Weight matrix, shape (I, O)

bias: Tensor1D<O, NoTape>

Bias vector, shape (O, )

Trait Implementations

impl<const I: usize, const O: usize> CanUpdateWithGradients for Linear<I, O>

fn update<G: GradientProvider>(&mut self, grads: &mut G)

impl<const I: usize, const O: usize> Clone for Linear<I, O>

fn clone(&self) -> Linear<I, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const I: usize, const O: usize> Debug for Linear<I, O>

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

Formats the value using the given formatter.

impl<const I: usize, const O: usize> Default for Linear<I, O>

fn default() -> Linear<I, O>

Returns the “default value” for a type.

impl<const I: usize, const O: usize> LoadFromNpz for Linear<I, O>

fn read<R>(
    &mut self,
    filename_prefix: &String,
    r: &mut ZipArchive<R>
) -> Result<(), NpzError> where
    R: Read + Seek, 

Reads self.weight from {filename_prefix}weight.npy and self.bias from {filename_prefix}bias.npy using numpy::read().

fn load<P: AsRef<Path>>(&mut self, path: P) -> Result<(), NpzError>

Loads data from a .npz zip archive at the specified path.

impl<const I: usize, const O: usize, H: Tape> Module<Tensor1D<I, H>> for Linear<I, O>

fn forward(&self, x: Tensor1D<I, H>) -> Self::Output

1d forward using vecmat_mul() and add().

type Output = Tensor1D<O, H>

impl<const B: usize, const I: usize, const O: usize, H: Tape> Module<Tensor2D<B, I, H>> for Linear<I, O>

fn forward(&self, x: Tensor2D<B, I, H>) -> Self::Output

Batched 2d forward using matmul() and broadcast_outer_add()

type Output = Tensor2D<B, O, H>

impl<const I: usize, const O: usize> Randomize<f32> for Linear<I, O>

fn randomize<R: Rng, D: Distribution<f32>>(&mut self, rng: &mut R, dist: &D)

impl<const I: usize, const O: usize> SaveToNpz for Linear<I, O>

fn write<W>(
    &self,
    filename_prefix: &String,
    w: &mut ZipWriter<W>
) -> ZipResult<()> where
    W: Write + Seek, 

Saves self.weight to {filename_prefix}weight.npy and self.bias to {filename_prefix}bias.npy using numpy::write().

fn save<P: AsRef<Path>>(&self, path: P) -> ZipResult<()>

Save this object into the .npz file determined located at path.