Struct dfdx::nn::modules::Linear

pub struct Linear<const I: usize, const O: usize, E: Dtype, D: Storage<E>> {
    pub weight: Tensor<Rank2<O, I>, E, D>,
    pub bias: Tensor<Rank1<O>, E, D>,
}

A linear transformation of the form weight * x + bias, where weight is a matrix, x is a vector or matrix, and bias is a vector.

Initializes Self::weight and Self::bias from a Uniform distribution between [-1 / sqrt(I), 1 / sqrt(I)].

Generics

• I The “input” size of vectors & matrices.
• O The “output” size of vectors & matrices.

Examples

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

type Model = Linear<5, 2>;
let model = dev.build_module::<Model, f32>();
// single item forward
let _: Tensor<Rank1<2>, f32, _> = model.forward(dev.zeros::<Rank1<5>>());
// batched forward
let _: Tensor<Rank2<10, 2>, f32, _> = model.forward(dev.zeros::<Rank2<10, 5>>());

Fields

weight: Tensor<Rank2<O, I>, E, D>

Transposed weight matrix, shape (I, O)

bias: Tensor<Rank1<O>, E, D>

Bias vector, shape (O, )

Trait Implementations

impl<const I: usize, const O: usize, E: Clone + Dtype, D: Clone + Storage<E>> Clone for Linear<I, O, E, D>

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

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, E: Debug + Dtype, D: Debug + Storage<E>> Debug for Linear<I, O, E, D>

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

Formats the value using the given formatter.

impl<const I: usize, const O: usize, E: Dtype, D: Device<E>, T> Module<T> for Linear<I, O, E, D>where T: SplitTape + TryMatMul<Tensor<Rank2<I, O>, E, D, T::Tape>> + HasErr<Err = D::Err>, T::Tape: Tape<E, D>, for<'a> Bias1D<'a, O, E, D>: Module<T::Output, Output = T::Output, Error = D::Err>,

fn try_forward(&self, x: T) -> Result<Self::Output, D::Err>

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

type Output = <T as TryMatMul<Tensor<(Const<I>, Const<O>), E, D, <T as SplitTape>::Tape>>>::Output

The type that this unit produces given Input.

type Error = <D as HasErr>::Err

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

Forward Input through the module and produce Module::Output.

impl<const I: usize, const O: usize, E: Dtype + Float + SampleUniform, D: Device<E>> TensorCollection<E, D> for Linear<I, O, E, D>

type To<E2: Dtype, D2: Device<E2>> = Linear<I, O, E2, D2>

Type alias that specifies the how a module’s type changes when using a different dtype and/or device.

fn iter_tensors<V: ModuleVisitor<Self, E, D>>( visitor: &mut V ) -> Result<Option<Self::To<V::E2, V::D2>>, V::Err>

Specifies how to iterate through tensors or modules containted within this module, and how to contruct this module given values for its fields. Returns Err(_) to indicate an error, Ok(None) to indicate that there is no error and a module has not been built, and Ok(Some(_)) contains Self::Output<E2, D2>

fn module<F1, F2, Field>( name: &str, get_ref: F1, get_mut: F2 ) -> ModuleField<'_, F1, F2, Self, Field>where F1: FnMut(&Self) -> &Field, F2: FnMut(&mut Self) -> &mut Field, Field: TensorCollection<E, D>,

Creates a ModuleFields that represents a field that may contain one or more tensors.

fn tensor<F1, F2, S>( name: &str, get_ref: F1, get_mut: F2, options: TensorOptions<S, E, D> ) -> TensorField<'_, F1, F2, Self, S, E, D>where F1: FnMut(&Self) -> &Tensor<S, E, D>, F2: FnMut(&mut Self) -> &mut Tensor<S, E, D>, S: Shape,

Creates a ModuleFields that represents a tensor field.

fn scalar<F1, F2, N>( name: &str, get_ref: F1, get_mut: F2, options: ScalarOptions<N> ) -> ScalarField<'_, F1, F2, Self, N>where F1: FnMut(&Self) -> &N, F2: FnMut(&mut Self) -> &mut N, N: NumCast,

Creates a ModuleFields that represents a scalar field.

impl<const I: usize, const O: usize, E: Dtype, D: Storage<E>> NonMutableModule for Linear<I, O, E, D>