Struct DynamicGraph 

pub struct DynamicGraph { /* private fields */ }

Dynamic computation graph that can modify its structure at runtime

This container provides a flexible execution framework for neural networks that need complex control flow, conditional execution, or runtime adaptation. It supports modules, conditions, combiners, and custom functions that can be composed into arbitrary computational graphs.

Examples

let mut graph = DynamicGraph::new();
graph.add_module("linear1".to_string(), Linear::new(784, 128, true));
graph.add_module("linear2".to_string(), Linear::new(128, 10, true));

// Create a simple sequential execution graph
let seq_graph = DynamicGraph::sequential(vec![
    "linear1".to_string(),
    "linear2".to_string(),
]);
graph.set_graph(seq_graph);

// Create input and run forward pass
let input = randn(&[1, 784])?;
let output = graph.forward(&input)?;

Implementations

impl DynamicGraph

pub fn new() -> Self

Create a new dynamic graph with a simple sequential structure

pub fn add_module<M: Module + 'static>(&mut self, name: String, module: M)

Add a module to the graph

pub fn add_condition<F>(&mut self, name: String, condition: F)

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

Add a condition function

pub fn add_combiner<F>(&mut self, name: String, combiner: F)

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

Add a combiner function for parallel execution

pub fn add_function<F>(&mut self, name: String, function: F)

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

Add a custom function

pub fn set_graph(&mut self, graph: GraphNode)

Set the execution graph

pub fn sequential(module_names: Vec<String>) -> GraphNode

Create a sequential graph from module names

pub fn conditional( condition: String, true_branch: GraphNode, false_branch: Option<GraphNode>, ) -> GraphNode

Create a conditional graph

pub fn parallel(nodes: Vec<GraphNode>, combiner: String) -> GraphNode

Create a parallel graph

pub fn loop_graph( body: GraphNode, condition: String, max_iterations: usize, ) -> GraphNode

Create a loop graph

pub fn get_execution_history(&self) -> Vec<String>

Get execution history for debugging

pub fn clear_execution_history(&self)

Clear execution history

pub fn modify_graph<F>(&mut self, modifier: F)

where F: FnOnce(&mut GraphNode),

Dynamically modify the graph at runtime

pub fn get_module(&self, name: &str) -> Option<&dyn Module>

Get a reference to a specific module

pub fn replace_module<M: Module + 'static>(&mut self, name: String, module: M)

Replace a module at runtime

pub fn remove_module(&mut self, name: &str) -> Option<Box<dyn Module>>

Remove a module

pub fn module_count(&self) -> usize

Get the number of modules

pub fn module_names(&self) -> Vec<&String>

List all module names

pub fn condition_names(&self) -> Vec<&String>

List all condition names

pub fn combiner_names(&self) -> Vec<&String>

List all combiner names

pub fn function_names(&self) -> Vec<&String>

List all function names

Trait Implementations

impl Default for DynamicGraph

fn default() -> Self

Returns the “default value” for a type.

impl Module for DynamicGraph

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 buffers(&self) -> Vec<Arc<RwLock<Tensor>>>

Get all buffers (non-trainable parameters)

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

Get named buffers

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

Get all direct child modules with names

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