Struct drug::Graph

pub struct Graph {
    pub optimizer: Optimizer,
    pub named_idxs: BTreeMap<String, Idx>,
    /* private fields */
}

A differentiable computation graph. Use this struct to hold your differentiable program which is a directed acyclic graph of Nodes, their associated values and losses (gradients). The graph computes values moving forward in insertion order (see forward method) and propagates losses backwards in reverse insertion order (see backward method). The default graph comes with an xavier initializer and a vanilla stochastic gradient descent optimizer.

Fields

optimizer: Optimizer

named_idxs: BTreeMap<String, Idx>

Implementations

impl Graph

pub fn new(
    initializer: Box<dyn Fn(&[usize]) -> ArrayD<f32>>,
    optimizer: Optimizer
) -> Self

Consider using Graph::default() if you don’t want to choose your own optimizer and initializer.

pub fn register(&mut self, node: Node) -> Idx

Inserts the node into the graph and returns the index

pub fn param(&mut self, shape: &[usize]) -> Idx

Registers a parameter of the given shape and initializes the value using the graph’s initializer.

pub fn input(&mut self, it: Option<Box<dyn Iterator<Item = ArrayD<f32>>>>) -> Idx

Registers an input node which advances the iterator it each forward pass.

pub fn op(&mut self, op: impl Operation + 'static, inputs: &[Idx]) -> Idx

Registers an operation and its inputs

pub fn constant(&mut self, c: ArrayD<f32>) -> Idx

Registers a constant, sets its value to c, then returns the idx

pub fn forward(&mut self)

Computes values for each node in insertion order. Parameters are unaffected. Inputs will set their value to the next output of their iterator, Operations will compute a new value based on the values of its inputs.

pub fn backward(&mut self)

Propagates gradients in reverse insertion order. Parameters will apply gradients with the graph’s optimizer. Inputs are unaffected Operations will compute gradient given values from their inputs and gradients from its outputs

pub fn forward1(&mut self, i: Idx)

Updates value and resets losses for node with Idx i.

pub fn backward1(&mut self, i: Idx)

Back propagates losses for node with Idx i.

pub fn remove(&mut self, idx: Idx)

Remove the node at idx as well as its associated value and loss.

pub fn clear_non_parameters(&mut self)

This op removes every node from the graph that is not a parameter. This is useful for dynamic graphs and recurrent neural networks when you want to rebuild everything each forward and backward pass of the network.

pub fn set_value(&mut self, idx: Idx, val: ArrayD<f32>)

pub fn get_value(&self, idx: Idx) -> &ArrayD<f32>

pub fn set_loss(&mut self, idx: Idx, loss: ArrayD<f32>)

pub fn get_loss(&self, idx: Idx) -> &ArrayD<f32>

pub fn replace_input_iterator(
    &mut self,
    idx: Idx,
    new: Box<dyn Iterator<Item = ArrayD<f32>>>
) -> Result<(), String>

Replace an Input node’s iterator or converts Constant nodes into Input with this iterator. Note that Input node iterators are not saved when serialized with serde.

pub fn add(&mut self, inputs: &[Idx]) -> Idx

pub fn mult(&mut self, inputs: &[Idx]) -> Idx

pub fn conv(
    &mut self,
    kernel: Idx,
    img: Idx,
    padding: Padding,
    stride: usize
) -> Idx

Registers a convolution operation node and returns the index

pub fn global_pool(&mut self, x: Idx, pool: GlobalPool) -> Idx

Registers a pooling operation takes a Batch * Height * Width * Channels image and reduces it to a Batch * Channels vector.

pub fn relu(&mut self, x: Idx) -> Idx

Registers a Relu operation which takes the elementwise maximum of the input array and 0.

pub fn sigmoid(&mut self, x: Idx) -> Idx

Registers a new sigmoid activation operation, an elementwise application of $\frac{ 1 }{1 - e^{-x}}$.

pub fn tanh(&mut self, x: Idx) -> Idx

Registers a Tanh operation.

pub fn matmul(&mut self, mat: Idx, v: Idx) -> Idx

Registers a matrix multiplication of vectors v by matrix mat.

pub fn embedding(&mut self, emb: Idx, code: Idx) -> Idx

Registers an embedding later that converts A0 to vector representation

Trait Implementations

impl Debug for Graph

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

Formats the value using the given formatter.

impl Default for Graph

fn default() -> Self

xavier initializer and normal gradient descent

impl<'de> Deserialize<'de> for Graph

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Graph

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

Formats the value using the given formatter.

impl Serialize for Graph

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.