Struct auto_diff::compute_graph::Net

pub struct Net { /* private fields */ }

The computation network. Connection has duplication.

Implementations

impl Net

pub fn new() -> Net

pub fn get_data(&self) -> &GenIndex<Tensor>

pub fn get_data_mut(&mut self) -> &mut GenIndex<Tensor>

pub fn get_op(&self, func: &Func) -> Option<&Op>

pub fn is_dangling_var(&self, var: &Var) -> Result<bool, ()>

pub fn get_grad(&self) -> &BTreeMap<NetIndex, Tensor>

pub fn get_func_output(&self, func: &Func) -> Option<NetIndex>

Return one output variable id if there is one.

pub fn init_var(&mut self) -> NetIndex

Insert an empty var into the network.

pub fn drop_var(&mut self, var: &Var)

pub fn init_op(&mut self, op: Op) -> NetIndex

Insert operator into the network.

pub fn init_func(&mut self, funcs: &[NetIndex]) -> NetIndex

For Module::func, insert a new composed func.

pub fn del_func_or_op(&mut self, func: &Func)

Remove a concrete op or composed func from the graph.

pub fn decouple_input(&mut self, func: &Func) -> Vec<NetIndex>

Disconnect the variable and the function the variable is the input. Delete the variable if it becomes the dangling variable.

pub fn get_sub_func(&self, func: NetIndex) -> Vec<NetIndex>

Return a vec of sub ops for the given op. Empty should be returned if the input is a concrete op.

pub fn is_composed(&self, func: &Func) -> Result<bool, ()>

Check the func is concrete or not.

pub fn connect(&mut self, input: &[NetIndex], op: Op, output: &[NetIndex])

Build input-operator-output relation, with given components.

pub fn connect2(&mut self, input: &[&Var], func: &Func, output: &[&Var])

pub fn set_mark(&mut self, did: &NetIndex)

set the set_mark, set_mark is used to label var with input value with it.

pub fn unset_mark(&mut self, did: &NetIndex)

pub fn eval(&mut self) -> Result<(), BTreeSet<NetIndex>>

Merge two computation graph Forward evaluate the computaiton graph.

pub fn eval_op(&self, input: &[&Var], func: &Func, output: &[&Var])

pub fn bptt_scale(&mut self, r: f32)

pub fn bptt(&mut self, output_grad: &BTreeMap<NetIndex, Tensor>)

pub fn visit_op<F>(
    &mut self,
    closure: F,
    allow: Option<Vec<NetIndex>>,
    skip: Option<Vec<NetIndex>>
) where
    F: Fn(&Op), 

Iterate over all ops, no order guarantee

pub fn visit_data<F>(&mut self, closure: F) where
    F: Fn(NetIndex, &Tensor), 

pub fn append(&mut self, other: &mut Self)