Struct dfdx::nn::Repeated

pub struct Repeated<T, const N: usize> {
    pub modules: [T; N],
}

Repeats T N times. This requires that T’s input is the same as it’s output.

Generics

• T the Module to repeat
• N the number of times to repeat T.

Examples

type Model = Repeated<(Linear<10, 10>, ReLU), 5>;
let model: Model = Default::default();
let out: Tensor1D<10> = model.forward(Tensor1D::zeros());

Fields

modules: [T; N]

Trait Implementations

impl<T: CanUpdateWithGradients, const N: usize> CanUpdateWithGradients for Repeated<T, N>

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, const N: usize> Clone for Repeated<T, N>

fn clone(&self) -> Repeated<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for Repeated<T, N>

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

Formats the value using the given formatter.

impl<T: Default, const N: usize> Default for Repeated<T, N> where
    [T; N]: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, const N: usize> Index<usize> for Repeated<T, N>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: LoadFromNpz, const N: usize> LoadFromNpz for Repeated<T, N>

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

Calls LoadFromNpz::read(self.modules[i], ...) on each sub module. See LoadFromNpz.

E.g. for a two items with base == "", this will call:

1. self.modules[0].read("0.", r)
2. self.modules[1].read("1.", r)

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

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

impl<Input, T: Module<Input, Output = Input>, const N: usize> Module<Input> for Repeated<T, N>

type Output = <T 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, const N: usize> ResetParams for Repeated<T, N>

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, const N: usize> SaveToNpz for Repeated<T, N>

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

Calls SaveToNpz::write(self.modules[i], ...) on each sub module. See SaveToNpz.

E.g. for a two items with base == "", this will call:

1. self.modules[0].write("0.", w)
2. self.modules[1].write("1.", w)

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

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