Struct ReverseModeEngine 

pub struct ReverseModeEngine<T: ReverseScalar> { /* private fields */ }

Reverse-mode AD engine (gradient tape)

Implementations

impl<T: ReverseScalar> ReverseModeEngine<T>

pub fn new() -> Self

Create a new reverse-mode AD engine

pub fn set_recording(&mut self, recording: bool)

Enable/disable gradient recording.

While recording is disabled, subsequent operations are still evaluated and appended to the tape, but they are recorded as constants: they keep the tape’s index invariant intact while blocking gradient flow.

pub fn is_recording(&self) -> bool

Check if recording is enabled

pub fn enable_higher_order(&mut self, enabled: bool)

Enable higher-order gradients

pub fn higher_order_enabled(&self) -> bool

Whether higher-order gradient tracking is enabled

pub fn clear_tape(&mut self)

Clear the computation tape

pub fn tape_len(&self) -> usize

Number of nodes currently on the tape

pub fn create_variable( &mut self, name: &str, value: Array1<T>, requiresgrad: bool, ) -> usize

Create a variable with gradient tracking (1-D, shape [value.len()])

pub fn create_variable_with_shape( &mut self, name: &str, value: Array1<T>, shape: &[usize], requiresgrad: bool, ) -> Result<usize>

Create a variable with an explicit logical shape.

value is the row-major flattening of a tensor whose logical shape is shape; the product of shape must equal value.len().

pub fn create_constant(&mut self, value: Array1<T>) -> usize

Create a constant (no gradient tracking)

pub fn set_variable_value( &mut self, varid: usize, value: Array1<T>, ) -> Result<()>

Replace the value of an existing leaf variable.

The tape is marked dirty; ReverseModeEngine::forward (called automatically by ReverseModeEngine::backward) re-evaluates every dependent node.

pub fn set_variable_value_by_name( &mut self, name: &str, value: Array1<T>, ) -> Result<()>

Replace the value of an existing leaf variable, by name

pub fn add(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Addition operation

pub fn subtract(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Subtraction operation

pub fn multiply(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Element-wise multiplication operation

pub fn divide(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Element-wise division operation

pub fn power(&mut self, base: usize, exponent: T) -> Result<usize>

Power operation

pub fn exp(&mut self, input: usize) -> Result<usize>

Exponential function

pub fn log(&mut self, input: usize) -> Result<usize>

Natural logarithm

pub fn sin(&mut self, input: usize) -> Result<usize>

Sine function

pub fn cos(&mut self, input: usize) -> Result<usize>

Cosine function

pub fn tanh(&mut self, input: usize) -> Result<usize>

Hyperbolic tangent

pub fn sigmoid(&mut self, input: usize) -> Result<usize>

Sigmoid function

pub fn relu(&mut self, input: usize) -> Result<usize>

ReLU function

pub fn leaky_relu(&mut self, input: usize, alpha: f64) -> Result<usize>

Leaky ReLU function

pub fn matmul(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Matrix multiplication.

lhs must have logical shape [m, k]; rhs must have shape [k, n] or [k] (interpreted as a [k, 1] column). The result has shape [m, n] (or [m] when rhs was 1-D).

pub fn dot(&mut self, lhs: usize, rhs: usize) -> Result<usize>

Dot product of two vectors of equal length; produces a scalar node.

pub fn sum(&mut self, input: usize, _axis: Option<usize>) -> Result<usize>

Sum reduction over all elements

pub fn mean(&mut self, input: usize, _axis: Option<usize>) -> Result<usize>

Mean reduction over all elements

pub fn norm(&mut self, input: usize) -> Result<usize>

L2 norm over all elements

pub fn reshape(&mut self, input: usize, newshape: &[usize]) -> Result<usize>

Reshape operation (element count must be preserved)

pub fn forward(&mut self) -> Result<()>

Re-evaluate every non-leaf node of the tape from the current leaf values.

Nodes are visited in tape order, which is a valid topological order because every node’s index exceeds all of its inputs’ indices.

pub fn value(&self, varid: usize) -> Result<&Array1<T>>

Forward value of a node

pub fn value_by_name(&self, name: &str) -> Result<&Array1<T>>

Forward value of a node, by variable name

pub fn shape(&self, varid: usize) -> Result<&[usize]>

Logical shape of a node

pub fn scalar_value(&self, varid: usize) -> Result<T>

Scalar value of a node that holds exactly one element

pub fn backward( &mut self, outputid: usize, gradient: Option<Array1<T>>, ) -> Result<()>

Backward pass: compute gradients of outputid w.r.t. every leaf.

If gradient is None, the output is seeded with ones matching the output’s length.

pub fn get_gradient(&self, varid: usize) -> Option<&Array1<T>>

Get gradient for a variable

pub fn get_gradient_by_name(&self, name: &str) -> Option<&Array1<T>>

Get gradient by variable name

pub fn zero_gradients(&mut self)

Zero all gradients

pub fn get_all_gradients(&self) -> HashMap<String, Array1<T>>

Get all named variable gradients

pub fn get_tape_stats(&self) -> ReverseModeStats

Get tape statistics

Trait Implementations

impl<T: ReverseScalar> Default for ReverseModeEngine<T>

fn default() -> Self

Returns the “default value” for a type.