pub struct SplitInto<T>(pub T);
Expand description
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 = dev.build_module::<Model, f32>();
let _: (Tensor<Rank1<3>, f32, _>, Tensor<Rank1<7>, f32, _>) = model.forward(dev.zeros::<Rank1<5>>());
Tuple Fields§
§0: T
Trait Implementations§
source§impl<T: BuildOnDevice<D, E>, D: Device<E>, E: Dtype> BuildOnDevice<D, E> for SplitInto<T>
impl<T: BuildOnDevice<D, E>, D: Device<E>, E: Dtype> BuildOnDevice<D, E> for SplitInto<T>
source§impl<Input: SplitTape, A: Module<Input, Error = B::Error>, B: Module<Input>> Module<Input> for SplitInto<(A, B)>where
A::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: Module<Input, Error = B::Error>, B: Module<Input>> Module<Input> for SplitInto<(A, B)>where A::Output: SplitTape<Tape = Input::Tape>,
source§impl<Input: SplitTape, A: Module<Input, Error = C::Error>, B: Module<Input, Error = C::Error>, C: Module<Input>> Module<Input> for SplitInto<(A, B, C)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: Module<Input, Error = C::Error>, B: Module<Input, Error = C::Error>, C: Module<Input>> Module<Input> for SplitInto<(A, B, C)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <C as Module<Input>>::Output)
type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <C as Module<Input>>::Output)
The type that this unit produces given
Input
.type Error = <C as Module<Input>>::Error
fn try_forward(&self, x: Input) -> Result<Self::Output, C::Error>
source§impl<Input: SplitTape, A: Module<Input, Error = D::Error>, B: Module<Input, Error = D::Error>, C: Module<Input, Error = D::Error>, D: Module<Input>> Module<Input> for SplitInto<(A, B, C, D)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: Module<Input, Error = D::Error>, B: Module<Input, Error = D::Error>, C: Module<Input, Error = D::Error>, D: Module<Input>> Module<Input> for SplitInto<(A, B, C, D)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <D as Module<Input>>::Output)
type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <D as Module<Input>>::Output)
The type that this unit produces given
Input
.type Error = <D as Module<Input>>::Error
fn try_forward(&self, x: Input) -> Result<Self::Output, D::Error>
source§impl<Input: SplitTape, A: Module<Input, Error = E::Error>, B: Module<Input, Error = E::Error>, C: Module<Input, Error = E::Error>, D: Module<Input, Error = E::Error>, E: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
D::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: Module<Input, Error = E::Error>, B: Module<Input, Error = E::Error>, C: Module<Input, Error = E::Error>, D: Module<Input, Error = E::Error>, E: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>, D::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <<D as Module<Input>>::Output as SplitTape>::NoTape, <E as Module<Input>>::Output)
type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <<D as Module<Input>>::Output as SplitTape>::NoTape, <E as Module<Input>>::Output)
The type that this unit produces given
Input
.type Error = <E as Module<Input>>::Error
fn try_forward(&self, x: Input) -> Result<Self::Output, E::Error>
source§impl<Input: SplitTape, A: Module<Input, Error = F::Error>, B: Module<Input, Error = F::Error>, C: Module<Input, Error = F::Error>, D: Module<Input, Error = F::Error>, E: Module<Input, Error = F::Error>, F: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E, F)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
D::Output: SplitTape<Tape = Input::Tape>,
E::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: Module<Input, Error = F::Error>, B: Module<Input, Error = F::Error>, C: Module<Input, Error = F::Error>, D: Module<Input, Error = F::Error>, E: Module<Input, Error = F::Error>, F: Module<Input>> Module<Input> for SplitInto<(A, B, C, D, E, F)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>, D::Output: SplitTape<Tape = Input::Tape>, E::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <<D as Module<Input>>::Output as SplitTape>::NoTape, <<E as Module<Input>>::Output as SplitTape>::NoTape, <F as Module<Input>>::Output)
type Output = (<<A as Module<Input>>::Output as SplitTape>::NoTape, <<B as Module<Input>>::Output as SplitTape>::NoTape, <<C as Module<Input>>::Output as SplitTape>::NoTape, <<D as Module<Input>>::Output as SplitTape>::NoTape, <<E as Module<Input>>::Output as SplitTape>::NoTape, <F as Module<Input>>::Output)
The type that this unit produces given
Input
.type Error = <F as Module<Input>>::Error
fn try_forward(&self, x: Input) -> Result<Self::Output, F::Error>
source§impl<Input: SplitTape, A: ModuleMut<Input, Error = B::Error>, B: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B)>where
A::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: ModuleMut<Input, Error = B::Error>, B: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B)>where A::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <B as ModuleMut<Input>>::Output)
type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <B as ModuleMut<Input>>::Output)
The type that this unit produces given
Input
.type Error = <B as ModuleMut<Input>>::Error
fn try_forward_mut(&mut self, x: Input) -> Result<Self::Output, B::Error>
source§fn forward_mut(&mut self, input: Input) -> Self::Output
fn forward_mut(&mut self, input: Input) -> Self::Output
source§impl<Input: SplitTape, A: ModuleMut<Input, Error = C::Error>, B: ModuleMut<Input, Error = C::Error>, C: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: ModuleMut<Input, Error = C::Error>, B: ModuleMut<Input, Error = C::Error>, C: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <C as ModuleMut<Input>>::Output)
type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <C as ModuleMut<Input>>::Output)
The type that this unit produces given
Input
.type Error = <C as ModuleMut<Input>>::Error
fn try_forward_mut(&mut self, x: Input) -> Result<Self::Output, C::Error>
source§fn forward_mut(&mut self, input: Input) -> Self::Output
fn forward_mut(&mut self, input: Input) -> Self::Output
source§impl<Input: SplitTape, A: ModuleMut<Input, Error = D::Error>, B: ModuleMut<Input, Error = D::Error>, C: ModuleMut<Input, Error = D::Error>, D: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: ModuleMut<Input, Error = D::Error>, B: ModuleMut<Input, Error = D::Error>, C: ModuleMut<Input, Error = D::Error>, D: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <D as ModuleMut<Input>>::Output)
type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <D as ModuleMut<Input>>::Output)
The type that this unit produces given
Input
.type Error = <D as ModuleMut<Input>>::Error
fn try_forward_mut(&mut self, x: Input) -> Result<Self::Output, D::Error>
source§fn forward_mut(&mut self, input: Input) -> Self::Output
fn forward_mut(&mut self, input: Input) -> Self::Output
source§impl<Input: SplitTape, A: ModuleMut<Input, Error = E::Error>, B: ModuleMut<Input, Error = E::Error>, C: ModuleMut<Input, Error = E::Error>, D: ModuleMut<Input, Error = E::Error>, E: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D, E)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
D::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: ModuleMut<Input, Error = E::Error>, B: ModuleMut<Input, Error = E::Error>, C: ModuleMut<Input, Error = E::Error>, D: ModuleMut<Input, Error = E::Error>, E: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D, E)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>, D::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<D as ModuleMut<Input>>::Output as SplitTape>::NoTape, <E as ModuleMut<Input>>::Output)
type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<D as ModuleMut<Input>>::Output as SplitTape>::NoTape, <E as ModuleMut<Input>>::Output)
The type that this unit produces given
Input
.type Error = <E as ModuleMut<Input>>::Error
fn try_forward_mut(&mut self, x: Input) -> Result<Self::Output, E::Error>
source§fn forward_mut(&mut self, input: Input) -> Self::Output
fn forward_mut(&mut self, input: Input) -> Self::Output
source§impl<Input: SplitTape, A: ModuleMut<Input, Error = F::Error>, B: ModuleMut<Input, Error = F::Error>, C: ModuleMut<Input, Error = F::Error>, D: ModuleMut<Input, Error = F::Error>, E: ModuleMut<Input, Error = F::Error>, F: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D, E, F)>where
A::Output: SplitTape<Tape = Input::Tape>,
B::Output: SplitTape<Tape = Input::Tape>,
C::Output: SplitTape<Tape = Input::Tape>,
D::Output: SplitTape<Tape = Input::Tape>,
E::Output: SplitTape<Tape = Input::Tape>,
impl<Input: SplitTape, A: ModuleMut<Input, Error = F::Error>, B: ModuleMut<Input, Error = F::Error>, C: ModuleMut<Input, Error = F::Error>, D: ModuleMut<Input, Error = F::Error>, E: ModuleMut<Input, Error = F::Error>, F: ModuleMut<Input>> ModuleMut<Input> for SplitInto<(A, B, C, D, E, F)>where A::Output: SplitTape<Tape = Input::Tape>, B::Output: SplitTape<Tape = Input::Tape>, C::Output: SplitTape<Tape = Input::Tape>, D::Output: SplitTape<Tape = Input::Tape>, E::Output: SplitTape<Tape = Input::Tape>,
§type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<D as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<E as ModuleMut<Input>>::Output as SplitTape>::NoTape, <F as ModuleMut<Input>>::Output)
type Output = (<<A as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<B as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<C as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<D as ModuleMut<Input>>::Output as SplitTape>::NoTape, <<E as ModuleMut<Input>>::Output as SplitTape>::NoTape, <F as ModuleMut<Input>>::Output)
The type that this unit produces given
Input
.type Error = <F as ModuleMut<Input>>::Error
fn try_forward_mut(&mut self, x: Input) -> Result<Self::Output, F::Error>
source§fn forward_mut(&mut self, input: Input) -> Self::Output
fn forward_mut(&mut self, input: Input) -> Self::Output
source§impl<E: Dtype, D: Device<E>, T: TensorCollection<E, D>> TensorCollection<E, D> for SplitInto<T>
impl<E: Dtype, D: Device<E>, T: TensorCollection<E, D>> TensorCollection<E, D> for SplitInto<T>
§type To<E2: Dtype, D2: Device<E2>> = SplitInto<<T as TensorCollection<E, D>>::To<E2, D2>>
type To<E2: Dtype, D2: Device<E2>> = SplitInto<<T as TensorCollection<E, D>>::To<E2, D2>>
Type alias that specifies the how a module’s type changes when using a different dtype and/or
device.
source§fn iter_tensors<V: ModuleVisitor<Self, E, D>>(
visitor: &mut V
) -> Result<Option<Self::To<V::E2, V::D2>>, V::Err>
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>
source§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>,
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. Read more
source§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,
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. Read more