Struct Sequential 

pub struct Sequential { /* private fields */ }

Sequential container

Implementations

impl Sequential

pub fn new() -> Self

Create a new sequential container

pub fn add<M: Module + 'static>(self, module: M) -> Self

Add a module to the sequential container

pub fn add_fn<F>(self, f: F) -> Self

where F: Fn(&Tensor) -> Result<Tensor> + Send + Sync + 'static,

Add a function as a module

Trait Implementations

impl Debug for Sequential

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

Formats the value using the given formatter.

impl Default for Sequential

fn default() -> Self

Returns the “default value” for a type.

impl Module for Sequential

fn buffers(&self) -> Vec<Arc<RwLock<Tensor>>>

Every child’s buffers, in child order.

Without this override the container answered the trait default (Vec::new()), so a Sequential holding a BatchNorm reported zero buffers and its state_dict() silently dropped every running statistic — a saved model reloaded with freshly initialized statistics and evaluated differently, with no error anywhere. See tests/hardening_nn_state_dict.rs.

fn named_buffers(&self) -> HashMap<String, Arc<RwLock<Tensor>>>

The same buffers as Self::buffers, keyed "{index}.{name}" — the key scheme Self::named_parameters already uses, so the parameter and buffer halves of a checkpoint agree on how to address a child.

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

The same children as Self::children, addressed by their index.

Every name-carrying recursion in the trait (all_named_parameters, all_named_buffers, named_modules) walks named_children(), not children(). Overriding only the latter left the container invisible to all three.

fn forward(&self, input: &Tensor) -> Result<Tensor>

Forward pass through the module

fn parameters(&self) -> HashMap<String, Parameter>

Get all parameters in the module (non-recursive)

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

Get named parameters (non-recursive)

fn train(&mut self)

Set training mode

fn eval(&mut self)

Set evaluation mode

fn training(&self) -> bool

Check if in training mode

fn set_training(&mut self, training: bool)

Set training mode (internal implementation)

fn to_device(&mut self, device: DeviceType) -> Result<()>

Move module to device

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

Get all direct child modules

fn all_parameters(&self) -> HashMap<String, Parameter>

Get all parameters recursively including submodules

fn all_named_parameters(&self) -> HashMap<String, Parameter>

Get all named parameters recursively with module prefixes

fn all_named_buffers(&self) -> HashMap<String, Arc<RwLock<Tensor>>>

Get all named buffers recursively with module prefixes

fn load_state_dict( &mut self, state_dict: &HashMap<String, Tensor>, strict: bool, ) -> Result<()>

Load state dictionary into the module

fn load_state_dict_strict( &mut self, state_dict: &HashMap<String, Tensor>, ) -> Result<()>

Load state dictionary with default strict=true

fn state_dict(&self) -> HashMap<String, Tensor>

Save state dictionary from the module

fn name(&self) -> Option<&str>

Get the module name (optional, for debugging and serialization)

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

where Self: Sized,

Get all modules recursively (depth-first traversal)

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

where Self: Sized,

Get all modules recursively with hierarchical names

fn zero_grad(&mut self)

Zero all gradients recursively

fn num_parameters(&self) -> usize

Count total number of parameters

fn num_trainable_parameters(&self) -> usize

Count trainable parameters

fn memory_usage(&self) -> usize

Get memory usage estimate in bytes

fn freeze(&mut self)

Freeze all parameters (set requires_grad = false)

fn unfreeze(&mut self)

Unfreeze all parameters (set requires_grad = true)

fn extra_repr(&self) -> String

Get string representation

fn register_hook( &mut self, _hook_type: HookType, _callback: HookCallback, ) -> Option<HookHandle>

Register a hook for this module (default implementation does nothing)

fn remove_hook(&mut self, _hook_type: HookType, _handle: HookHandle) -> bool

Remove a hook by handle (default implementation does nothing)

fn execute_hooks( &self, _hook_type: HookType, _input: &Tensor, _output: Option<&Tensor>, ) -> Result<()>

Execute hooks of a specific type (default implementation does nothing)

fn forward_with_hooks(&self, input: &Tensor) -> Result<Tensor>

Forward pass with hooks support

fn has_hooks(&self, _hook_type: HookType) -> bool

Check if module has hooks registered

fn call(&self, input: &Tensor) -> Result<Tensor>

Convenient method to call forward and handle common patterns

fn apply(&self, input: &Tensor) -> Result<Tensor>

Apply the module to input (alias for forward)

fn has_parameters(&self) -> bool

Check if the module has any parameters

fn has_children(&self) -> bool

Check if the module has any child modules

fn parameter_count(&self) -> usize

Get parameter count (convenience method)

fn trainable_parameter_count(&self) -> usize

Get trainable parameter count (convenience method)

fn memory_usage_mb(&self) -> f64

Get memory usage in MB (convenience method)

fn toggle_training(&mut self)

Toggle training mode (convenience method)

fn eval_mode(&self) -> bool

Check if module is in evaluation mode

fn sequential_forward(modules: &[&dyn Module], input: Tensor) -> Result<Tensor>

where Self: Sized,

Sequential forward pass through multiple modules

fn batch_forward(&self, inputs: &[Tensor]) -> Result<Vec<Tensor>>

Apply module multiple times with different inputs (batch processing)

fn conditional_forward(&self, input: &Tensor, condition: bool) -> Result<Tensor>

Forward with condition - only apply if condition is true

fn residual_forward(&self, input: &Tensor) -> Result<Tensor>

Forward with residual connection

fn module_info(&self) -> ModuleInfo

Get detailed module information for debugging

fn check_training_readiness(&self) -> Result<()>

Check if module is ready for training

fn parameter_names_matching(&self, pattern: &str) -> Vec<String>

Get parameter names matching a pattern

fn parameters_by_type(&self, param_type: &str) -> HashMap<String, Parameter>

Get parameters by layer type (e.g., “weight”, “bias”)

fn clone_parameters(&self) -> HashMap<String, Tensor>

Clone module parameters (for creating copies or checkpoints)

fn diagnose(&self) -> ModuleDiagnostics

Quick diagnostic check of module health