Struct dfdx::nn::SplitInto

pub struct SplitInto<T>(pub T);

Splits input into multiple heads. T should be a tuple, where every element of the tuple accepts the same input type.

This provides a utility for multi headed structures where the tape needs to be moved around a number of times.

Generics

• T the module to split the input into.

Examples

type Model = SplitInto<(Linear<5, 3>, Linear<5, 7>)>;
let model: Model = Default::default();
let _: (Tensor1D<3>, Tensor1D<7>) = model.forward(Tensor1D::<5>::zeros());

Tuple Fields

0: T

Trait Implementations

impl<T: CanUpdateWithGradients> CanUpdateWithGradients for SplitInto<T>

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

Updates self given the GradientProvider. When any parameters that are NOT present in G, then this function should add the tensor’s UniqueId to UnusedTensors.

impl<T: Clone> Clone for SplitInto<T>

fn clone(&self) -> SplitInto<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SplitInto<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for SplitInto<T>

fn default() -> SplitInto<T>

Returns the “default value” for a type.

impl<T: LoadFromNpz> LoadFromNpz for SplitInto<T>

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

Reads this object from a ZipArchive. r with a base filename of filename_prefix.

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

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

impl<Input: Tensor, A: Module<Input>, B: Module<Input>, C: Module<Input>, D: Module<Input>, E: Module<Input>, F: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E, F)> where
    A::Output: Tensor<Tape = Input::Tape>,
    B::Output: Tensor<Tape = Input::Tape>,
    C::Output: Tensor<Tape = Input::Tape>,
    D::Output: Tensor<Tape = Input::Tape>,
    E::Output: Tensor<Tape = Input::Tape>, 

type Output = (<<A as Module<Input>>::Output as Tensor>::NoTape, <<B as Module<Input>>::Output as Tensor>::NoTape, <<C as Module<Input>>::Output as Tensor>::NoTape, <<D as Module<Input>>::Output as Tensor>::NoTape, <<E as Module<Input>>::Output as Tensor>::NoTape, <F as Module<Input>>::Output)

The type that this unit produces given Input.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

impl<Input: Tensor, A: Module<Input>, B: Module<Input>, C: Module<Input>, D: Module<Input>, E: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E)> where
    A::Output: Tensor<Tape = Input::Tape>,
    B::Output: Tensor<Tape = Input::Tape>,
    C::Output: Tensor<Tape = Input::Tape>,
    D::Output: Tensor<Tape = Input::Tape>, 

type Output = (<<A as Module<Input>>::Output as Tensor>::NoTape, <<B as Module<Input>>::Output as Tensor>::NoTape, <<C as Module<Input>>::Output as Tensor>::NoTape, <<D as Module<Input>>::Output as Tensor>::NoTape, <E as Module<Input>>::Output)

The type that this unit produces given Input.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

impl<Input: Tensor, A: Module<Input>, B: Module<Input>, C: Module<Input>, D: Module<Input>> Module<Input> for SplitInto<(A, B, C, D)> where
    A::Output: Tensor<Tape = Input::Tape>,
    B::Output: Tensor<Tape = Input::Tape>,
    C::Output: Tensor<Tape = Input::Tape>, 

type Output = (<<A as Module<Input>>::Output as Tensor>::NoTape, <<B as Module<Input>>::Output as Tensor>::NoTape, <<C as Module<Input>>::Output as Tensor>::NoTape, <D as Module<Input>>::Output)

The type that this unit produces given Input.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

impl<Input: Tensor, A: Module<Input>, B: Module<Input>, C: Module<Input>> Module<Input> for SplitInto<(A, B, C)> where
    A::Output: Tensor<Tape = Input::Tape>,
    B::Output: Tensor<Tape = Input::Tape>, 

type Output = (<<A as Module<Input>>::Output as Tensor>::NoTape, <<B as Module<Input>>::Output as Tensor>::NoTape, <C as Module<Input>>::Output)

The type that this unit produces given Input.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

impl<Input: Tensor, A: Module<Input>, B: Module<Input>> Module<Input> for SplitInto<(A, B)> where
    A::Output: Tensor<Tape = Input::Tape>, 

type Output = (<<A as Module<Input>>::Output as Tensor>::NoTape, <B as Module<Input>>::Output)

The type that this unit produces given Input.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

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

Pass an Input through the unit and produce Self::Output. Can be implemented for multiple Input types.

impl<T: ResetParams> ResetParams for SplitInto<T>

fn reset_params<R: Rng>(&mut self, rng: &mut R)

Mutate the unit’s parameters using rand::Rng. Each implementor of this trait decides how the parameters are initialized. In fact, some impls may not even use the rng.

impl<T: SaveToNpz> SaveToNpz for SplitInto<T>

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

Write this object into ZipWriter w with a base filename of filename_prefix.

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

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