Struct CheckpointedNetwork 

pub struct CheckpointedNetwork<R: Recomputable<Input = Vec<f32>, Output = Vec<f32>>> { /* private fields */ }

A sequential network where every layer boundary is checkpointed.

During the forward pass, each segment’s output is fed as input to the next segment, but only the inputs are retained — outputs are discarded. On demand (e.g., during the backward pass) any segment’s output can be recovered by calling checkpoint.recompute().

This type is generic over any Recomputable whose Input and Output are both Vec<f32>, making it suitable for chain-of-linear-segments networks.

Implementations

impl<R: Recomputable<Input = Vec<f32>, Output = Vec<f32>>> CheckpointedNetwork<R>

pub fn new(segments: Vec<Checkpoint<R>>) -> Self

Construct the network from pre-built checkpoints.

pub fn forward(&self, _input: &[f32]) -> Vec<f32>

Execute the full forward pass, returning the output of the final segment.

Internally each segment is run in order; the checkpointed inputs are already stored so we merely recompute each in sequence.

Returns an error if segments is empty.

pub fn memory_bytes(&self) -> usize

Total bytes used by all checkpointed inputs.

pub fn full_memory_bytes(&self) -> usize

Hypothetical memory if we stored every segment’s output instead of its input.

For a typical expanding network (out_dim > in_dim) this will be larger than memory_bytes, demonstrating the checkpointing advantage.

pub fn memory_savings(&self) -> f32

Fraction of memory saved relative to storing all outputs.

Returns a value in [0, 1). A result of 0.0 means no savings (input == output size everywhere); values near 1.0 mean the full-storage cost would be much higher.