Struct ModuleDict 

pub struct ModuleDict<T: Float> { /* private fields */ }

An ordered dictionary of named modules, registered for parameter tracking.

Uses a Vec<(String, Box<dyn Module<T>>)> internally to preserve insertion order without requiring an external dependency like IndexMap.

Like ModuleList, ModuleDict does not define a forward pass. Users look up modules by key and call forward() manually. This mirrors PyTorch’s nn.ModuleDict.

Named parameters

Parameters are prefixed by their dictionary key: "encoder.weight", "decoder.weight", etc.

Examples

fn example(input: &Tensor<f32>) -> Result<Tensor<f32>, FerrotorchError> {
    let mut dict = ModuleDict::<f32>::new();
    dict.insert("encoder", Box::new(Linear::<f32>::new(784, 256, true)?));
    dict.insert("decoder", Box::new(Linear::<f32>::new(256, 784, true)?));

    let encoder = dict.get("encoder").ok_or_else(|| FerrotorchError::InvalidArgument {
        message: "missing 'encoder' module".into(),
    })?;
    let decoder = dict.get("decoder").ok_or_else(|| FerrotorchError::InvalidArgument {
        message: "missing 'decoder' module".into(),
    })?;
    let encoded = encoder.forward(input)?;
    decoder.forward(&encoded)
}

Implementations

impl<T: Float> ModuleDict<T>

pub fn new() -> Self

Create an empty module dict.

pub fn insert(&mut self, key: impl Into<String>, module: Box<dyn Module<T>>)

Insert a module with the given key.

If a module with the same key already exists, it is replaced (preserving insertion position).

pub fn get(&self, key: &str) -> Option<&dyn Module<T>>

Get a reference to the module with the given key.

pub fn get_mut(&mut self, key: &str) -> Option<&mut dyn Module<T>>

Get a mutable reference to the module with the given key.

pub fn keys(&self) -> Vec<&str>

Return the keys in insertion order.

pub fn len(&self) -> usize

Number of entries.

pub fn is_empty(&self) -> bool

Whether the dict is empty.

Trait Implementations

impl<T: Float> Default for ModuleDict<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Float> Display for ModuleDict<T>

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

Formats the value using the given formatter.

impl<T: Float> Module<T> for ModuleDict<T>

fn forward(&self, _input: &Tensor<T>) -> FerrotorchResult<Tensor<T>>

ModuleDict does not implement forward.

Users should look up modules by key and call forward() manually.

fn parameters(&self) -> Vec<&Parameter<T>>

Iterate over all learnable parameters.

fn parameters_mut(&mut self) -> Vec<&mut Parameter<T>>

Iterate over all learnable parameters mutably.

fn named_parameters(&self) -> Vec<(String, &Parameter<T>)>

Named parameters for state dict serialization.

fn train(&mut self)

Set training mode. Affects dropout, batchnorm, etc.

fn eval(&mut self)

Set evaluation mode.

fn is_training(&self) -> bool

Whether the module is in training mode.

fn to_device(&mut self, device: Device) -> FerrotorchResult<()>

Move all parameters and buffers to a device.

fn state_dict(&self) -> StateDict<T>

Export parameters and buffers as a state dict (torch parity).

fn buffers(&self) -> Vec<&Buffer<T>>

Iterate over all non-trainable buffers (e.g. running mean / variance in BatchNorm). Default returns empty — concrete modules with buffers override.

fn buffers_mut(&mut self) -> Vec<&mut Buffer<T>>

Mutable iteration over all buffers. Default returns empty.

fn named_buffers(&self) -> Vec<(String, &Buffer<T>)>

Named buffers (dot-separated paths for nested modules). Default returns empty.

fn as_any(&self) -> Option<&dyn Any>

Downcast hook for type-erased buffer-loader dispatch. (#984)

fn children(&self) -> Vec<&dyn Module<T>>

Direct child modules. Default returns empty (leaf module).

fn named_children(&self) -> Vec<(String, &dyn Module<T>)>

Direct child modules with their attribute names. Default returns empty.

fn modules(&self) -> Vec<&dyn Module<T>>

where Self: Sized,

All modules in this subtree, depth-first (self first, then each child’s descendants in order).

fn descendants_dyn(&self) -> Vec<&dyn Module<T>>

All strict descendants of self in depth-first order. Object-safe.

fn named_modules(&self) -> Vec<(String, &dyn Module<T>)>

where Self: Sized,

All modules in this subtree with dot-separated path names. The root is named ""; children paths are joined with ..

fn named_descendants_dyn(&self) -> Vec<(String, &dyn Module<T>)>

Strict descendants with dot-paths. Object-safe.

fn with_forward_hook( self, hook: ForwardHook<T>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a forward hook. Returns the wrapper paired with a HookHandle that can be used to remove the hook later. The wrapper implements Module<T> itself, so it slots into any place the original module did. Mirrors torch.nn.Module.register_forward_hook.

fn with_forward_pre_hook( self, hook: ForwardPreHook<T>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a forward pre-hook. See Self::with_forward_hook. Mirrors torch.nn.Module.register_forward_pre_hook.

fn with_backward_hook( self, hook: BackwardHook<T>, ) -> (HookedModule<Self, T>, HookHandle)

where Self: Sized,

Wrap this module in a HookedModule and register a backward hook. See Self::with_forward_hook. Mirrors torch.nn.Module.register_backward_hook.

fn zero_grad(&self) -> FerrotorchResult<()>

Set the gradient of every parameter to None.

fn requires_grad_(&mut self, requires_grad: bool)

Toggle requires_grad on every parameter (freeze / unfreeze the module). Mirrors torch.nn.Module.requires_grad_.

fn apply_to_parameters(&mut self, f: &mut dyn FnMut(&mut Parameter<T>))

Apply a function to every parameter in this module. Mirrors torch.nn.Module.apply for the parameter case (true apply recurses over all submodules; the recursive form requires &mut dyn Module which conflicts with this trait’s &mut self borrow).

fn load_state_dict( &mut self, state: &StateDict<T>, strict: bool, ) -> FerrotorchResult<()>

Load parameters from a state dict.