Struct dfdx::nn::modules::AddInto

pub struct AddInto<T>(pub T);

Add inputs together into a single tensor. T should be a tuple

This provides a utility for networks where multiple inputs are needed

Generics

• T the module to add the outputs together of

Examples

type Model = AddInto<(Linear<2, 5>, Linear<3, 5>)>;
let model = dev.build_module::<Model, f32>();
let a: Tensor<Rank1<2>, f32, _> = dev.zeros();
let b: Tensor<Rank1<3>, f32, _> = dev.zeros();
let _: Tensor<Rank1<5>, f32, _> = model.forward((a, b));

Tuple Fields

0: T

Trait Implementations

impl<T: BuildOnDevice<D, E>, D: Device<E>, E: Dtype> BuildOnDevice<D, E> for AddInto<T>

type Built = AddInto<<T as BuildOnDevice<D, E>>::Built>

fn build_on_device(device: &D) -> Self::Built

fn try_build_on_device(device: &D) -> Result<Self::Built, D::Err>

impl<T: Clone> Clone for AddInto<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for AddInto<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for AddInto<T>

fn default() -> AddInto<T>

Returns the “default value” for a type.

impl<Out: Add<Out, Output = Out>, Ai, Bi, A: Module<Ai, Output = Out>, B: Module<Bi, Output = Out, Error = A::Error>> Module<(Ai, Bi)> for AddInto<(A, B)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as Module<Ai>>::Error

fn try_forward(&self, x: (Ai, Bi)) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, A: Module<Ai, Output = Out>, B: Module<Bi, Output = Out, Error = A::Error>, C: Module<Ci, Output = Out, Error = A::Error>> Module<(Ai, Bi, Ci)> for AddInto<(A, B, C)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as Module<Ai>>::Error

fn try_forward(&self, x: (Ai, Bi, Ci)) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, A: Module<Ai, Output = Out>, B: Module<Bi, Output = Out, Error = A::Error>, C: Module<Ci, Output = Out, Error = A::Error>, D: Module<Di, Output = Out, Error = A::Error>> Module<(Ai, Bi, Ci, Di)> for AddInto<(A, B, C, D)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as Module<Ai>>::Error

fn try_forward(&self, x: (Ai, Bi, Ci, Di)) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, Ei, A: Module<Ai, Output = Out>, B: Module<Bi, Output = Out, Error = A::Error>, C: Module<Ci, Output = Out, Error = A::Error>, D: Module<Di, Output = Out, Error = A::Error>, E: Module<Ei, Output = Out, Error = A::Error>> Module<(Ai, Bi, Ci, Di, Ei)> for AddInto<(A, B, C, D, E)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as Module<Ai>>::Error

fn try_forward( &self, x: (Ai, Bi, Ci, Di, Ei) ) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, Ei, Fi, A: Module<Ai, Output = Out>, B: Module<Bi, Output = Out, Error = A::Error>, C: Module<Ci, Output = Out, Error = A::Error>, D: Module<Di, Output = Out, Error = A::Error>, E: Module<Ei, Output = Out, Error = A::Error>, F: Module<Fi, Output = Out, Error = A::Error>> Module<(Ai, Bi, Ci, Di, Ei, Fi)> for AddInto<(A, B, C, D, E, F)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as Module<Ai>>::Error

fn try_forward( &self, x: (Ai, Bi, Ci, Di, Ei, Fi) ) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, A: ModuleMut<Ai, Output = Out>, B: ModuleMut<Bi, Output = Out, Error = A::Error>> ModuleMut<(Ai, Bi)> for AddInto<(A, B)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as ModuleMut<Ai>>::Error

fn try_forward_mut(&mut self, x: (Ai, Bi)) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, A: ModuleMut<Ai, Output = Out>, B: ModuleMut<Bi, Output = Out, Error = A::Error>, C: ModuleMut<Ci, Output = Out, Error = A::Error>> ModuleMut<(Ai, Bi, Ci)> for AddInto<(A, B, C)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as ModuleMut<Ai>>::Error

fn try_forward_mut( &mut self, x: (Ai, Bi, Ci) ) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, A: ModuleMut<Ai, Output = Out>, B: ModuleMut<Bi, Output = Out, Error = A::Error>, C: ModuleMut<Ci, Output = Out, Error = A::Error>, D: ModuleMut<Di, Output = Out, Error = A::Error>> ModuleMut<(Ai, Bi, Ci, Di)> for AddInto<(A, B, C, D)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as ModuleMut<Ai>>::Error

fn try_forward_mut( &mut self, x: (Ai, Bi, Ci, Di) ) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, Ei, A: ModuleMut<Ai, Output = Out>, B: ModuleMut<Bi, Output = Out, Error = A::Error>, C: ModuleMut<Ci, Output = Out, Error = A::Error>, D: ModuleMut<Di, Output = Out, Error = A::Error>, E: ModuleMut<Ei, Output = Out, Error = A::Error>> ModuleMut<(Ai, Bi, Ci, Di, Ei)> for AddInto<(A, B, C, D, E)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as ModuleMut<Ai>>::Error

fn try_forward_mut( &mut self, x: (Ai, Bi, Ci, Di, Ei) ) -> Result<Self::Output, Self::Error>

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

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

impl<Out: Add<Out, Output = Out>, Ai, Bi, Ci, Di, Ei, Fi, A: ModuleMut<Ai, Output = Out>, B: ModuleMut<Bi, Output = Out, Error = A::Error>, C: ModuleMut<Ci, Output = Out, Error = A::Error>, D: ModuleMut<Di, Output = Out, Error = A::Error>, E: ModuleMut<Ei, Output = Out, Error = A::Error>, F: ModuleMut<Fi, Output = Out, Error = A::Error>> ModuleMut<(Ai, Bi, Ci, Di, Ei, Fi)> for AddInto<(A, B, C, D, E, F)>

type Output = Out

The type that this unit produces given Input.

type Error = <A as ModuleMut<Ai>>::Error

fn try_forward_mut( &mut self, x: (Ai, Bi, Ci, Di, Ei, Fi) ) -> Result<Self::Output, Self::Error>

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

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

impl<E: Dtype, D: Device<E>, T: TensorCollection<E, D>> TensorCollection<E, D> for AddInto<T>

type To<E2: Dtype, D2: Device<E2>> = AddInto<<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.

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.